Domain Flow API

Auth

authChangePassword

Change password


/auth/change-password

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/auth/change-password" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AuthChangePasswordRequest authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

try {
    final result = await api_instance.authChangePassword(authChangePasswordRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authChangePassword: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
AuthChangePasswordRequest *authChangePasswordRequest = ; // 

// Change password
[apiInstance authChangePasswordWith:authChangePasswordRequest
              completionHandler: ^(auth_logout_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var authChangePasswordRequest = ; // {AuthChangePasswordRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authChangePassword(authChangePasswordRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authChangePasswordExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

            try {
                // Change password
                auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authChangePassword: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$authChangePasswordRequest = ; // AuthChangePasswordRequest | 

try {
    $result = $api_instance->authChangePassword($authChangePasswordRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authChangePassword: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $authChangePasswordRequest = WWW::OPenAPIClient::Object::AuthChangePasswordRequest->new(); # AuthChangePasswordRequest | 

eval {
    my $result = $api_instance->authChangePassword(authChangePasswordRequest => $authChangePasswordRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authChangePassword: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
authChangePasswordRequest =  # AuthChangePasswordRequest | 

try:
    # Change password
    api_response = api_instance.auth_change_password(authChangePasswordRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authChangePassword: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let authChangePasswordRequest = ; // AuthChangePasswordRequest

    let mut context = AuthApi::Context::default();
    let result = client.authChangePassword(authChangePasswordRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
authChangePasswordRequest *

Responses


authLogin

User login


/auth/login

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/auth/login" \
 -d '{
  "password" : "password",
  "email" : "email"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            auth_login_200_response result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.authLogin(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogin: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            auth_login_200_response result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
LoginRequest *loginRequest = ; // 

// User login
[apiInstance authLoginWith:loginRequest
              completionHandler: ^(auth_login_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var loginRequest = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogin(loginRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLoginExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // User login
                auth_login_200_response result = apiInstance.authLogin(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogin: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$loginRequest = ; // LoginRequest | 

try {
    $result = $api_instance->authLogin($loginRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogin: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->authLogin(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogin: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
loginRequest =  # LoginRequest | 

try:
    # User login
    api_response = api_instance.auth_login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogin: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = AuthApi::Context::default();
    let result = client.authLogin(loginRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
loginRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


authLogout

User logout


/auth/logout

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/auth/logout"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_logout_200_response result = apiInstance.authLogout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authLogout();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogout: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_logout_200_response result = apiInstance.authLogout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// User logout
[apiInstance authLogoutWithCompletionHandler: 
              ^(auth_logout_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogout(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLogoutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // User logout
                auth_logout_200_response result = apiInstance.authLogout();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogout: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authLogout();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogout: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authLogout();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogout: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # User logout
    api_response = api_instance.auth_logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogout: %s\n" % e)
extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authLogout(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


authMe

Get current user


/auth/me

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/auth/me"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_me_200_response result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authMe();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authMe: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_me_200_response result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Get current user
[apiInstance authMeWithCompletionHandler: 
              ^(auth_me_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authMe(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authMeExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Get current user
                auth_me_200_response result = apiInstance.authMe();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authMe: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authMe();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authMe: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authMe();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authMe: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Get current user
    api_response = api_instance.auth_me()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authMe: %s\n" % e)
extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authMe(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


authRefresh

Refresh session


/auth/refresh

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/auth/refresh"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_login_200_response result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authRefresh();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authRefresh: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_login_200_response result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Refresh session
[apiInstance authRefreshWithCompletionHandler: 
              ^(auth_login_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authRefresh(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authRefreshExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Refresh session
                auth_login_200_response result = apiInstance.authRefresh();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authRefresh: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authRefresh();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authRefresh: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authRefresh();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authRefresh: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Refresh session
    api_response = api_instance.auth_refresh()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authRefresh: %s\n" % e)
extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authRefresh(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Campaigns

allocateBulkResources

Allocate bulk operation resources


/campaigns/bulk/resources/allocate

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/resources/allocate" \
 -d '{
  "duration" : 48837,
  "resources" : {
    "memory" : 77,
    "cpu" : 6,
    "storage" : 596,
    "networkBandwidth" : 1474
  },
  "operationType" : "domain_generation",
  "priority" : "normal",
  "tags" : {
    "key" : "tags"
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkResourceAllocationRequest bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

try {
    final result = await api_instance.allocateBulkResources(bulkResourceAllocationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->allocateBulkResources: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkResourceAllocationRequest *bulkResourceAllocationRequest = ; // 

// Allocate bulk operation resources
[apiInstance allocateBulkResourcesWith:bulkResourceAllocationRequest
              completionHandler: ^(allocateBulkResources_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkResourceAllocationRequest = ; // {BulkResourceAllocationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.allocateBulkResources(bulkResourceAllocationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allocateBulkResourcesExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

            try {
                // Allocate bulk operation resources
                allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.allocateBulkResources: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

try {
    $result = $api_instance->allocateBulkResources($bulkResourceAllocationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->allocateBulkResources: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkResourceAllocationRequest = WWW::OPenAPIClient::Object::BulkResourceAllocationRequest->new(); # BulkResourceAllocationRequest | 

eval {
    my $result = $api_instance->allocateBulkResources(bulkResourceAllocationRequest => $bulkResourceAllocationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->allocateBulkResources: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkResourceAllocationRequest =  # BulkResourceAllocationRequest | 

try:
    # Allocate bulk operation resources
    api_response = api_instance.allocate_bulk_resources(bulkResourceAllocationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->allocateBulkResources: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.allocateBulkResources(bulkResourceAllocationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkResourceAllocationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkAnalyzeDomains

Bulk domain analysis


/campaigns/bulk/domains/analyze

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/analyze" \
 -d '{
  "granularity" : "day",
  "aggregation" : {
    "functions" : [ "sum", "sum" ],
    "groupBy" : [ "groupBy", "groupBy" ]
  },
  "campaignIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
  "metrics" : [ "response_time", "response_time" ],
  "timeRange" : {
    "timezone" : "UTC",
    "startTime" : "2000-01-23T04:56:07.000+00:00",
    "endTime" : "2000-01-23T04:56:07.000+00:00"
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkAnalyticsRequest bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

try {
    final result = await api_instance.bulkAnalyzeDomains(bulkAnalyticsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkAnalyzeDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkAnalyticsRequest *bulkAnalyticsRequest = ; // 

// Bulk domain analysis
[apiInstance bulkAnalyzeDomainsWith:bulkAnalyticsRequest
              completionHandler: ^(bulkAnalyzeDomains_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkAnalyticsRequest = ; // {BulkAnalyticsRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkAnalyzeDomains(bulkAnalyticsRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkAnalyzeDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

            try {
                // Bulk domain analysis
                bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkAnalyzeDomains: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

try {
    $result = $api_instance->bulkAnalyzeDomains($bulkAnalyticsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkAnalyzeDomains: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkAnalyticsRequest = WWW::OPenAPIClient::Object::BulkAnalyticsRequest->new(); # BulkAnalyticsRequest | 

eval {
    my $result = $api_instance->bulkAnalyzeDomains(bulkAnalyticsRequest => $bulkAnalyticsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkAnalyzeDomains: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkAnalyticsRequest =  # BulkAnalyticsRequest | 

try:
    # Bulk domain analysis
    api_response = api_instance.bulk_analyze_domains(bulkAnalyticsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkAnalyzeDomains: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkAnalyticsRequest = ; // BulkAnalyticsRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkAnalyzeDomains(bulkAnalyticsRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkAnalyticsRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkGenerateDomains

Bulk domain generation


/campaigns/bulk/domains/generate

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/generate" \
 -d '{
  "operations" : [ {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 1,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 1,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 1,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 1,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 1,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  } ],
  "parallel" : true,
  "batchSize" : 5637
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDomainGenerationRequest bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

try {
    final result = await api_instance.bulkGenerateDomains(bulkDomainGenerationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkGenerateDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDomainGenerationRequest *bulkDomainGenerationRequest = ; // 

// Bulk domain generation
[apiInstance bulkGenerateDomainsWith:bulkDomainGenerationRequest
              completionHandler: ^(bulkGenerateDomains_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDomainGenerationRequest = ; // {BulkDomainGenerationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkGenerateDomains(bulkDomainGenerationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkGenerateDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

            try {
                // Bulk domain generation
                bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkGenerateDomains: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

try {
    $result = $api_instance->bulkGenerateDomains($bulkDomainGenerationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkGenerateDomains: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDomainGenerationRequest = WWW::OPenAPIClient::Object::BulkDomainGenerationRequest->new(); # BulkDomainGenerationRequest | 

eval {
    my $result = $api_instance->bulkGenerateDomains(bulkDomainGenerationRequest => $bulkDomainGenerationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkGenerateDomains: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDomainGenerationRequest =  # BulkDomainGenerationRequest | 

try:
    # Bulk domain generation
    api_response = api_instance.bulk_generate_domains(bulkDomainGenerationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkGenerateDomains: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkGenerateDomains(bulkDomainGenerationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkDomainGenerationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkValidateDNS

Bulk DNS validation


/campaigns/bulk/domains/validate-dns

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/validate-dns" \
 -d '{
  "operations" : [ {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  } ],
  "stealth" : {
    "delayRange" : {
      "min" : 5,
      "max" : 2
    },
    "enabled" : true,
    "randomizationLevel" : "medium"
  },
  "batchSize" : 596
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDNSValidationRequest bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

try {
    final result = await api_instance.bulkValidateDNS(bulkDNSValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateDNS: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDNSValidationRequest *bulkDNSValidationRequest = ; // 

// Bulk DNS validation
[apiInstance bulkValidateDNSWith:bulkDNSValidationRequest
              completionHandler: ^(bulkValidateDNS_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDNSValidationRequest = ; // {BulkDNSValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateDNS(bulkDNSValidationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateDNSExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

            try {
                // Bulk DNS validation
                bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateDNS: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

try {
    $result = $api_instance->bulkValidateDNS($bulkDNSValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateDNS: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDNSValidationRequest = WWW::OPenAPIClient::Object::BulkDNSValidationRequest->new(); # BulkDNSValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateDNS(bulkDNSValidationRequest => $bulkDNSValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateDNS: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDNSValidationRequest =  # BulkDNSValidationRequest | 

try:
    # Bulk DNS validation
    api_response = api_instance.bulk_validate_dns(bulkDNSValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateDNS: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkDNSValidationRequest = ; // BulkDNSValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateDNS(bulkDNSValidationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkDNSValidationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkValidateHTTP

Bulk HTTP validation


/campaigns/bulk/domains/validate-http

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/validate-http" \
 -d '{
  "operations" : [ {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  } ],
  "stealth" : {
    "delayRange" : {
      "min" : 5,
      "max" : 2
    },
    "enabled" : true,
    "randomizationLevel" : "high"
  },
  "batchSize" : 74
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkHTTPValidationRequest bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

try {
    final result = await api_instance.bulkValidateHTTP(bulkHTTPValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateHTTP: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkHTTPValidationRequest *bulkHTTPValidationRequest = ; // 

// Bulk HTTP validation
[apiInstance bulkValidateHTTPWith:bulkHTTPValidationRequest
              completionHandler: ^(bulkValidateDNS_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkHTTPValidationRequest = ; // {BulkHTTPValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateHTTP(bulkHTTPValidationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateHTTPExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

            try {
                // Bulk HTTP validation
                bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateHTTP: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

try {
    $result = $api_instance->bulkValidateHTTP($bulkHTTPValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateHTTP: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkHTTPValidationRequest = WWW::OPenAPIClient::Object::BulkHTTPValidationRequest->new(); # BulkHTTPValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateHTTP(bulkHTTPValidationRequest => $bulkHTTPValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateHTTP: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkHTTPValidationRequest =  # BulkHTTPValidationRequest | 

try:
    # Bulk HTTP validation
    api_response = api_instance.bulk_validate_http(bulkHTTPValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateHTTP: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateHTTP(bulkHTTPValidationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkHTTPValidationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


campaignsBulkOperationsList

List bulk operations


/campaigns/bulk/operations

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/operations"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsBulkOperationsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsBulkOperationsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List bulk operations
[apiInstance campaignsBulkOperationsListWithCompletionHandler: 
              ^(campaigns_bulk_operations_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsBulkOperationsList(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsBulkOperationsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List bulk operations
                campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsBulkOperationsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsBulkOperationsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsBulkOperationsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsBulkOperationsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsBulkOperationsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List bulk operations
    api_response = api_instance.campaigns_bulk_operations_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsBulkOperationsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsBulkOperationsList(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


campaignsClassificationsGet

Get campaign classification buckets


/campaigns/{campaignId}/classifications

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/classifications?limit=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 

        try {
            campaigns_classifications_get_200_response result = apiInstance.campaignsClassificationsGet(campaignId, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsClassificationsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Integer limit = new Integer(); // Integer | 

try {
    final result = await api_instance.campaignsClassificationsGet(campaignId, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsClassificationsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 

        try {
            campaigns_classifications_get_200_response result = apiInstance.campaignsClassificationsGet(campaignId, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsClassificationsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Integer *limit = 56; //  (optional) (default to 5)

// Get campaign classification buckets
[apiInstance campaignsClassificationsGetWith:campaignId
    limit:limit
              completionHandler: ^(campaigns_classifications_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'limit': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsClassificationsGet(campaignId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsClassificationsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to 5)

            try {
                // Get campaign classification buckets
                campaigns_classifications_get_200_response result = apiInstance.campaignsClassificationsGet(campaignId, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsClassificationsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$limit = 56; // Integer | 

try {
    $result = $api_instance->campaignsClassificationsGet($campaignId, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsClassificationsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $limit = 56; # Integer | 

eval {
    my $result = $api_instance->campaignsClassificationsGet(campaignId => $campaignId, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsClassificationsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
limit = 56 # Integer |  (optional) (default to 5)

try:
    # Get campaign classification buckets
    api_response = api_instance.campaigns_classifications_get(campaignId, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsClassificationsGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsClassificationsGet(campaignId, limit, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Query parameters
Name Description
limit
Integer

Responses


campaignsCreate

Create campaign


/campaigns

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns" \
 -d '{
  "configuration" : {
    "patternConfig" : {
      "charset" : "charset",
      "tlds" : [ "tlds", "tlds" ],
      "keywordSetIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
      "constant" : "constant",
      "targetDomains" : [ "targetDomains", "targetDomains" ],
      "projectionEstimate" : {
        "key" : ""
      },
      "variableLength" : 10,
      "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
      "type" : "constant",
      "crawlDepth" : 2
    },
    "maxDomains" : 80083,
    "phases" : {
      "discovery" : {
        "maxDepth" : 6,
        "enabled" : true
      },
      "extraction" : {
        "keywordSetIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
        "enabled" : true
      },
      "analysis" : {
        "generateReports" : true,
        "enabled" : true
      },
      "validation" : {
        "dnsValidation" : true,
        "enabled" : true,
        "httpValidation" : true
      }
    }
  },
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

try {
    final result = await api_instance.campaignsCreate(createCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsCreate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
CreateCampaignRequest *createCampaignRequest = ; // 

// Create campaign
[apiInstance campaignsCreateWith:createCampaignRequest
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var createCampaignRequest = ; // {CreateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsCreate(createCampaignRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

            try {
                // Create campaign
                campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$createCampaignRequest = ; // CreateCampaignRequest | 

try {
    $result = $api_instance->campaignsCreate($createCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $createCampaignRequest = WWW::OPenAPIClient::Object::CreateCampaignRequest->new(); # CreateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsCreate(createCampaignRequest => $createCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
createCampaignRequest =  # CreateCampaignRequest | 

try:
    # Create campaign
    api_response = api_instance.campaigns_create(createCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsCreate: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let createCampaignRequest = ; // CreateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsCreate(createCampaignRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createCampaignRequest *

Responses


campaignsDelete

Delete campaign


/campaigns/{campaignId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign
[apiInstance campaignsDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsDelete(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign
                apiInstance.campaignsDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign
    api_instance.campaigns_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDelete: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsDomainGenerationPatternOffset

Get current global pattern offset for domain generation config


/campaigns/domain-generation/pattern-offset

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/domain-generation/pattern-offset" \
 -d '{
  "characterSet" : "characterSet",
  "variableLength" : 0,
  "patternType" : "prefix",
  "constantString" : "constantString",
  "tld" : "tld"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PatternOffsetRequest patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

try {
    final result = await api_instance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainGenerationPatternOffset: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
PatternOffsetRequest *patternOffsetRequest = ; // 

// Get current global pattern offset for domain generation config
[apiInstance campaignsDomainGenerationPatternOffsetWith:patternOffsetRequest
              completionHandler: ^(campaigns_domain_generation_pattern_offset_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var patternOffsetRequest = ; // {PatternOffsetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainGenerationPatternOffset(patternOffsetRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainGenerationPatternOffsetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

            try {
                // Get current global pattern offset for domain generation config
                campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainGenerationPatternOffset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$patternOffsetRequest = ; // PatternOffsetRequest | 

try {
    $result = $api_instance->campaignsDomainGenerationPatternOffset($patternOffsetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $patternOffsetRequest = WWW::OPenAPIClient::Object::PatternOffsetRequest->new(); # PatternOffsetRequest | 

eval {
    my $result = $api_instance->campaignsDomainGenerationPatternOffset(patternOffsetRequest => $patternOffsetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
patternOffsetRequest =  # PatternOffsetRequest | 

try:
    # Get current global pattern offset for domain generation config
    api_response = api_instance.campaigns_domain_generation_pattern_offset(patternOffsetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let patternOffsetRequest = ; // PatternOffsetRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainGenerationPatternOffset(patternOffsetRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
patternOffsetRequest *

Responses


campaignsDomainScoreBreakdown

Get component score breakdown for a single domain

Recomputes the scoring component values for the specified domain using the stored feature vector and current (or default) scoring profile weights. Does not persist anything; purely diagnostic / transparency surface. If experimental tf-lite scoring is disabled the `tf_lite` key will still be present with value 0.


/campaigns/{campaignId}/domains/{domain}/score-breakdown

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/domains/{domain}/score-breakdown"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String domain = domain_example; // String | 

        try {
            campaigns_domain_score_breakdown_200_response result = apiInstance.campaignsDomainScoreBreakdown(campaignId, domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainScoreBreakdown");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String domain = new String(); // String | 

try {
    final result = await api_instance.campaignsDomainScoreBreakdown(campaignId, domain);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainScoreBreakdown: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String domain = domain_example; // String | 

        try {
            campaigns_domain_score_breakdown_200_response result = apiInstance.campaignsDomainScoreBreakdown(campaignId, domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainScoreBreakdown");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *domain = domain_example; //  (default to null)

// Get component score breakdown for a single domain
[apiInstance campaignsDomainScoreBreakdownWith:campaignId
    domain:domain
              completionHandler: ^(campaigns_domain_score_breakdown_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var domain = domain_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainScoreBreakdown(campaignId, domain, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainScoreBreakdownExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var domain = domain_example;  // String |  (default to null)

            try {
                // Get component score breakdown for a single domain
                campaigns_domain_score_breakdown_200_response result = apiInstance.campaignsDomainScoreBreakdown(campaignId, domain);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainScoreBreakdown: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$domain = domain_example; // String | 

try {
    $result = $api_instance->campaignsDomainScoreBreakdown($campaignId, $domain);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainScoreBreakdown: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $domain = domain_example; # String | 

eval {
    my $result = $api_instance->campaignsDomainScoreBreakdown(campaignId => $campaignId, domain => $domain);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainScoreBreakdown: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
domain = domain_example # String |  (default to null)

try:
    # Get component score breakdown for a single domain
    api_response = api_instance.campaigns_domain_score_breakdown(campaignId, domain)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainScoreBreakdown: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let domain = domain_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainScoreBreakdown(campaignId, domain, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
domain*
String
Required

Responses


campaignsDomainsList

List generated domains for a campaign


/campaigns/{campaignId}/domains

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/domains?limit=56&offset=56&dnsStatus=dnsStatus_example&httpStatus=httpStatus_example&dnsReason=dnsReason_example&httpReason=httpReason_example&minScore=3.4¬Parked=true&hasContact=true&keyword=keyword_example&sort=sort_example&dir=dir_example&warnings=warnings_example&first=56&after=after_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String dnsStatus = dnsStatus_example; // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
        String httpStatus = httpStatus_example; // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
        String dnsReason = dnsReason_example; // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
        String httpReason = httpReason_example; // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
        Float minScore = 3.4; // Float | Minimum inclusive domain score to include
        Boolean notParked = true; // Boolean | Exclude domains detected as parked
        Boolean hasContact = true; // Boolean | Only include domains with detected contact signals
        String keyword = keyword_example; // String | Require at least one keyword match (any)
        String sort = sort_example; // String | Richness-based sort field (defaults to richness_score when omitted)
        String dir = dir_example; // String | Sort direction (defaults to desc)
        String warnings = warnings_example; // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
        Integer first = 56; // Integer | Page size for cursor pagination (overrides limit when present)
        String after = after_example; // String | Cursor token to continue listing after

        try {
            campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final String dnsStatus = new String(); // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
final String httpStatus = new String(); // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
final String dnsReason = new String(); // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
final String httpReason = new String(); // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
final Float minScore = new Float(); // Float | Minimum inclusive domain score to include
final Boolean notParked = new Boolean(); // Boolean | Exclude domains detected as parked
final Boolean hasContact = new Boolean(); // Boolean | Only include domains with detected contact signals
final String keyword = new String(); // String | Require at least one keyword match (any)
final String sort = new String(); // String | Richness-based sort field (defaults to richness_score when omitted)
final String dir = new String(); // String | Sort direction (defaults to desc)
final String warnings = new String(); // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
final Integer first = new Integer(); // Integer | Page size for cursor pagination (overrides limit when present)
final String after = new String(); // String | Cursor token to continue listing after

try {
    final result = await api_instance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String dnsStatus = dnsStatus_example; // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
        String httpStatus = httpStatus_example; // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
        String dnsReason = dnsReason_example; // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
        String httpReason = httpReason_example; // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
        Float minScore = 3.4; // Float | Minimum inclusive domain score to include
        Boolean notParked = true; // Boolean | Exclude domains detected as parked
        Boolean hasContact = true; // Boolean | Only include domains with detected contact signals
        String keyword = keyword_example; // String | Require at least one keyword match (any)
        String sort = sort_example; // String | Richness-based sort field (defaults to richness_score when omitted)
        String dir = dir_example; // String | Sort direction (defaults to desc)
        String warnings = warnings_example; // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
        Integer first = 56; // Integer | Page size for cursor pagination (overrides limit when present)
        String after = after_example; // String | Cursor token to continue listing after

        try {
            campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Integer *limit = 56; //  (optional) (default to 100)
Integer *offset = 56; //  (optional) (default to 0)
String *dnsStatus = dnsStatus_example; // Filter domains whose authoritative DNS status matches (pending|ok|error|timeout) (optional) (default to null)
String *httpStatus = httpStatus_example; // Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout) (optional) (default to null)
String *dnsReason = dnsReason_example; // Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR (optional) (default to null)
String *httpReason = httpReason_example; // Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR (optional) (default to null)
Float *minScore = 3.4; // Minimum inclusive domain score to include (optional) (default to null)
Boolean *notParked = true; // Exclude domains detected as parked (optional) (default to null)
Boolean *hasContact = true; // Only include domains with detected contact signals (optional) (default to null)
String *keyword = keyword_example; // Require at least one keyword match (any) (optional) (default to null)
String *sort = sort_example; // Richness-based sort field (defaults to richness_score when omitted) (optional) (default to null)
String *dir = dir_example; // Sort direction (defaults to desc) (optional) (default to null)
String *warnings = warnings_example; // Warning filter applied before sorting (has = only domains with penalties; none = only clean domains) (optional) (default to null)
Integer *first = 56; // Page size for cursor pagination (overrides limit when present) (optional) (default to null)
String *after = after_example; // Cursor token to continue listing after (optional) (default to null)

// List generated domains for a campaign
[apiInstance campaignsDomainsListWith:campaignId
    limit:limit
    offset:offset
    dnsStatus:dnsStatus
    httpStatus:httpStatus
    dnsReason:dnsReason
    httpReason:httpReason
    minScore:minScore
    notParked:notParked
    hasContact:hasContact
    keyword:keyword
    sort:sort
    dir:dir
    warnings:warnings
    first:first
    after:after
              completionHandler: ^(campaigns_domains_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'dnsStatus': dnsStatus_example, // {String} Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
  'httpStatus': httpStatus_example, // {String} Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
  'dnsReason': dnsReason_example, // {String} Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
  'httpReason': httpReason_example, // {String} Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
  'minScore': 3.4, // {Float} Minimum inclusive domain score to include
  'notParked': true, // {Boolean} Exclude domains detected as parked
  'hasContact': true, // {Boolean} Only include domains with detected contact signals
  'keyword': keyword_example, // {String} Require at least one keyword match (any)
  'sort': sort_example, // {String} Richness-based sort field (defaults to richness_score when omitted)
  'dir': dir_example, // {String} Sort direction (defaults to desc)
  'warnings': warnings_example, // {String} Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
  'first': 56, // {Integer} Page size for cursor pagination (overrides limit when present)
  'after': after_example // {String} Cursor token to continue listing after
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainsList(campaignId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to 100)
            var offset = 56;  // Integer |  (optional)  (default to 0)
            var dnsStatus = dnsStatus_example;  // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout) (optional)  (default to null)
            var httpStatus = httpStatus_example;  // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout) (optional)  (default to null)
            var dnsReason = dnsReason_example;  // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR (optional)  (default to null)
            var httpReason = httpReason_example;  // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR (optional)  (default to null)
            var minScore = 3.4;  // Float | Minimum inclusive domain score to include (optional)  (default to null)
            var notParked = true;  // Boolean | Exclude domains detected as parked (optional)  (default to null)
            var hasContact = true;  // Boolean | Only include domains with detected contact signals (optional)  (default to null)
            var keyword = keyword_example;  // String | Require at least one keyword match (any) (optional)  (default to null)
            var sort = sort_example;  // String | Richness-based sort field (defaults to richness_score when omitted) (optional)  (default to null)
            var dir = dir_example;  // String | Sort direction (defaults to desc) (optional)  (default to null)
            var warnings = warnings_example;  // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains) (optional)  (default to null)
            var first = 56;  // Integer | Page size for cursor pagination (overrides limit when present) (optional)  (default to null)
            var after = after_example;  // String | Cursor token to continue listing after (optional)  (default to null)

            try {
                // List generated domains for a campaign
                campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$dnsStatus = dnsStatus_example; // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
$httpStatus = httpStatus_example; // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
$dnsReason = dnsReason_example; // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
$httpReason = httpReason_example; // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
$minScore = 3.4; // Float | Minimum inclusive domain score to include
$notParked = true; // Boolean | Exclude domains detected as parked
$hasContact = true; // Boolean | Only include domains with detected contact signals
$keyword = keyword_example; // String | Require at least one keyword match (any)
$sort = sort_example; // String | Richness-based sort field (defaults to richness_score when omitted)
$dir = dir_example; // String | Sort direction (defaults to desc)
$warnings = warnings_example; // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
$first = 56; // Integer | Page size for cursor pagination (overrides limit when present)
$after = after_example; // String | Cursor token to continue listing after

try {
    $result = $api_instance->campaignsDomainsList($campaignId, $limit, $offset, $dnsStatus, $httpStatus, $dnsReason, $httpReason, $minScore, $notParked, $hasContact, $keyword, $sort, $dir, $warnings, $first, $after);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $dnsStatus = dnsStatus_example; # String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
my $httpStatus = httpStatus_example; # String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
my $dnsReason = dnsReason_example; # String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
my $httpReason = httpReason_example; # String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
my $minScore = 3.4; # Float | Minimum inclusive domain score to include
my $notParked = true; # Boolean | Exclude domains detected as parked
my $hasContact = true; # Boolean | Only include domains with detected contact signals
my $keyword = keyword_example; # String | Require at least one keyword match (any)
my $sort = sort_example; # String | Richness-based sort field (defaults to richness_score when omitted)
my $dir = dir_example; # String | Sort direction (defaults to desc)
my $warnings = warnings_example; # String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
my $first = 56; # Integer | Page size for cursor pagination (overrides limit when present)
my $after = after_example; # String | Cursor token to continue listing after

eval {
    my $result = $api_instance->campaignsDomainsList(campaignId => $campaignId, limit => $limit, offset => $offset, dnsStatus => $dnsStatus, httpStatus => $httpStatus, dnsReason => $dnsReason, httpReason => $httpReason, minScore => $minScore, notParked => $notParked, hasContact => $hasContact, keyword => $keyword, sort => $sort, dir => $dir, warnings => $warnings, first => $first, after => $after);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
limit = 56 # Integer |  (optional) (default to 100)
offset = 56 # Integer |  (optional) (default to 0)
dnsStatus = dnsStatus_example # String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout) (optional) (default to null)
httpStatus = httpStatus_example # String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout) (optional) (default to null)
dnsReason = dnsReason_example # String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR (optional) (default to null)
httpReason = httpReason_example # String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR (optional) (default to null)
minScore = 3.4 # Float | Minimum inclusive domain score to include (optional) (default to null)
notParked = true # Boolean | Exclude domains detected as parked (optional) (default to null)
hasContact = true # Boolean | Only include domains with detected contact signals (optional) (default to null)
keyword = keyword_example # String | Require at least one keyword match (any) (optional) (default to null)
sort = sort_example # String | Richness-based sort field (defaults to richness_score when omitted) (optional) (default to null)
dir = dir_example # String | Sort direction (defaults to desc) (optional) (default to null)
warnings = warnings_example # String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains) (optional) (default to null)
first = 56 # Integer | Page size for cursor pagination (overrides limit when present) (optional) (default to null)
after = after_example # String | Cursor token to continue listing after (optional) (default to null)

try:
    # List generated domains for a campaign
    api_response = api_instance.campaigns_domains_list(campaignId, limit=limit, offset=offset, dnsStatus=dnsStatus, httpStatus=httpStatus, dnsReason=dnsReason, httpReason=httpReason, minScore=minScore, notParked=notParked, hasContact=hasContact, keyword=keyword, sort=sort, dir=dir, warnings=warnings, first=first, after=after)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer
    let offset = 56; // Integer
    let dnsStatus = dnsStatus_example; // String
    let httpStatus = httpStatus_example; // String
    let dnsReason = dnsReason_example; // String
    let httpReason = httpReason_example; // String
    let minScore = 3.4; // Float
    let notParked = true; // Boolean
    let hasContact = true; // Boolean
    let keyword = keyword_example; // String
    let sort = sort_example; // String
    let dir = dir_example; // String
    let warnings = warnings_example; // String
    let first = 56; // Integer
    let after = after_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Query parameters
Name Description
limit
Integer
offset
Integer
dnsStatus
String
Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
httpStatus
String
Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
dnsReason
String
Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
httpReason
String
Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
minScore
Float (float)
Minimum inclusive domain score to include
notParked
Boolean
Exclude domains detected as parked
hasContact
Boolean
Only include domains with detected contact signals
keyword
String
Require at least one keyword match (any)
sort
String
Richness-based sort field (defaults to richness_score when omitted)
dir
String
Sort direction (defaults to desc)
warnings
String
Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
first
Integer
Page size for cursor pagination (overrides limit when present)
after
String
Cursor token to continue listing after

Responses


campaignsDuplicatePost

Duplicate campaign


/campaigns/{campaignId}/duplicate

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/duplicate"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsDuplicatePost(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDuplicatePost");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsDuplicatePost(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDuplicatePost: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsDuplicatePost(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDuplicatePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Duplicate campaign
[apiInstance campaignsDuplicatePostWith:campaignId
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDuplicatePost(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDuplicatePostExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Duplicate campaign
                campaigns_create_201_response result = apiInstance.campaignsDuplicatePost(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDuplicatePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsDuplicatePost($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDuplicatePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsDuplicatePost(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDuplicatePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Duplicate campaign
    api_response = api_instance.campaigns_duplicate_post(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDuplicatePost: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDuplicatePost(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsEnrichedGet

Get enriched campaign details

Returns campaign with state and recent phase executions as a single enriched read model


/campaigns/{campaignId}/enriched

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/enriched"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsEnrichedGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsEnrichedGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get enriched campaign details
[apiInstance campaignsEnrichedGetWith:campaignId
              completionHandler: ^(campaigns_enriched_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsEnrichedGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsEnrichedGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get enriched campaign details
                campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsEnrichedGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsEnrichedGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsEnrichedGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsEnrichedGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsEnrichedGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get enriched campaign details
    api_response = api_instance.campaigns_enriched_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsEnrichedGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsEnrichedGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsFunnelGet

Get campaign funnel snapshot


/campaigns/{campaignId}/funnel

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/funnel"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_funnel_get_200_response result = apiInstance.campaignsFunnelGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsFunnelGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsFunnelGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsFunnelGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_funnel_get_200_response result = apiInstance.campaignsFunnelGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsFunnelGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign funnel snapshot
[apiInstance campaignsFunnelGetWith:campaignId
              completionHandler: ^(campaigns_funnel_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsFunnelGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsFunnelGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign funnel snapshot
                campaigns_funnel_get_200_response result = apiInstance.campaignsFunnelGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsFunnelGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsFunnelGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsFunnelGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsFunnelGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsFunnelGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign funnel snapshot
    api_response = api_instance.campaigns_funnel_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsFunnelGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsFunnelGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsGet

Get campaign


/campaigns/{campaignId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign
[apiInstance campaignsGetWith:campaignId
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign
                campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign
    api_response = api_instance.campaigns_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsList

List campaigns


/campaigns

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_list_200_response result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_list_200_response result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List campaigns
[apiInstance campaignsListWithCompletionHandler: 
              ^(campaigns_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsList(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List campaigns
                campaigns_list_200_response result = apiInstance.campaignsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List campaigns
    api_response = api_instance.campaigns_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsList(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


campaignsMetricsGet

Get campaign KPI & warning metrics


/campaigns/{campaignId}/metrics

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/metrics"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_metrics_get_200_response result = apiInstance.campaignsMetricsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMetricsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsMetricsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsMetricsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_metrics_get_200_response result = apiInstance.campaignsMetricsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMetricsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign KPI & warning metrics
[apiInstance campaignsMetricsGetWith:campaignId
              completionHandler: ^(campaigns_metrics_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsMetricsGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsMetricsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign KPI & warning metrics
                campaigns_metrics_get_200_response result = apiInstance.campaignsMetricsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsMetricsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsMetricsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsMetricsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsMetricsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsMetricsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign KPI & warning metrics
    api_response = api_instance.campaigns_metrics_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsMetricsGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsMetricsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsModeUpdate

Update campaign execution mode


/campaigns/{campaignId}/mode

Usage and SDK Samples

curl -X PATCH \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/mode" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignsModeUpdateRequest campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

try {
    final result = await api_instance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsModeUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignsModeUpdateRequest *campaignsModeUpdateRequest = ; // 

// Update campaign execution mode
[apiInstance campaignsModeUpdateWith:campaignId
    campaignsModeUpdateRequest:campaignsModeUpdateRequest
              completionHandler: ^(campaigns_mode_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignsModeUpdateRequest = ; // {CampaignsModeUpdateRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsModeUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

            try {
                // Update campaign execution mode
                campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsModeUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

try {
    $result = $api_instance->campaignsModeUpdate($campaignId, $campaignsModeUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsModeUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignsModeUpdateRequest = WWW::OPenAPIClient::Object::CampaignsModeUpdateRequest->new(); # CampaignsModeUpdateRequest | 

eval {
    my $result = $api_instance->campaignsModeUpdate(campaignId => $campaignId, campaignsModeUpdateRequest => $campaignsModeUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsModeUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignsModeUpdateRequest =  # CampaignsModeUpdateRequest | 

try:
    # Update campaign execution mode
    api_response = api_instance.campaigns_mode_update(campaignId, campaignsModeUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsModeUpdate: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
campaignsModeUpdateRequest *

Responses


campaignsMomentumGet

Get campaign momentum & movers


/campaigns/{campaignId}/momentum

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/momentum"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_momentum_get_200_response result = apiInstance.campaignsMomentumGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMomentumGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsMomentumGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsMomentumGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_momentum_get_200_response result = apiInstance.campaignsMomentumGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMomentumGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign momentum & movers
[apiInstance campaignsMomentumGetWith:campaignId
              completionHandler: ^(campaigns_momentum_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsMomentumGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsMomentumGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign momentum & movers
                campaigns_momentum_get_200_response result = apiInstance.campaignsMomentumGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsMomentumGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsMomentumGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsMomentumGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsMomentumGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsMomentumGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign momentum & movers
    api_response = api_instance.campaigns_momentum_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsMomentumGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsMomentumGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsPhaseConfigsList

List stored phase configurations for a campaign


/campaigns/{campaignId}/configs

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/configs"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseConfigsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List stored phase configurations for a campaign
[apiInstance campaignsPhaseConfigsListWith:campaignId
              completionHandler: ^(campaigns_phase_configs_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigsList(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List stored phase configurations for a campaign
                campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseConfigsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseConfigsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List stored phase configurations for a campaign
    api_response = api_instance.campaigns_phase_configs_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigsList(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsPhaseConfigure

Configure campaign phase


/campaigns/{campaignId}/phases/{phase}/configure

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/configure" \
 -d '{
  "keywordSetIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
  "proxyPoolId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "configuration" : {
    "key" : ""
  },
  "personaIds" : {
    "httpPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "dnsPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 
final PhaseConfigurationRequest phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

try {
    final result = await api_instance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigure: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)
PhaseConfigurationRequest *phaseConfigurationRequest = ; // 

// Configure campaign phase
[apiInstance campaignsPhaseConfigureWith:campaignId
    phase:phase
    phaseConfigurationRequest:phaseConfigurationRequest
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 
var phaseConfigurationRequest = ; // {PhaseConfigurationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigureExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)
            var phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

            try {
                // Configure campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigure: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 
$phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

try {
    $result = $api_instance->campaignsPhaseConfigure($campaignId, $phase, $phaseConfigurationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigure: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 
my $phaseConfigurationRequest = WWW::OPenAPIClient::Object::PhaseConfigurationRequest->new(); # PhaseConfigurationRequest | 

eval {
    my $result = $api_instance->campaignsPhaseConfigure(campaignId => $campaignId, phase => $phase, phaseConfigurationRequest => $phaseConfigurationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigure: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)
phaseConfigurationRequest =  # PhaseConfigurationRequest | 

try:
    # Configure campaign phase
    api_response = api_instance.campaigns_phase_configure(campaignId, phase, phaseConfigurationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigure: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String
    let phaseConfigurationRequest = ; // PhaseConfigurationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required
Body parameters
Name Description
phaseConfigurationRequest *

Responses


campaignsPhaseExecutionDelete

Delete phase execution by phase type


/campaigns/{campaignId}/phase-executions/{phaseType}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions/{phaseType}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionDelete(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Delete phase execution by phase type
[apiInstance campaignsPhaseExecutionDeleteWith:campaignId
    phaseType:phaseType
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsPhaseExecutionDelete(campaignId, phaseType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Delete phase execution by phase type
                apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $api_instance->campaignsPhaseExecutionDelete($campaignId, $phaseType);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    $api_instance->campaignsPhaseExecutionDelete(campaignId => $campaignId, phaseType => $phaseType);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Delete phase execution by phase type
    api_instance.campaigns_phase_execution_delete(campaignId, phaseType)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionDelete(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phaseType*
String
Required

Responses


campaignsPhaseExecutionGet

Get phase execution by phase type


/campaigns/{campaignId}/phase-executions/{phaseType}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions/{phaseType}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionGet(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Get phase execution by phase type
[apiInstance campaignsPhaseExecutionGetWith:campaignId
    phaseType:phaseType
              completionHandler: ^(campaigns_phase_execution_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionGet(campaignId, phaseType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Get phase execution by phase type
                campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $result = $api_instance->campaignsPhaseExecutionGet($campaignId, $phaseType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionGet(campaignId => $campaignId, phaseType => $phaseType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Get phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_get(campaignId, phaseType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionGet(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phaseType*
String
Required

Responses


campaignsPhaseExecutionPut

Update phase execution by phase type


/campaigns/{campaignId}/phase-executions/{phaseType}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions/{phaseType}" \
 -d '{
  "completedAt" : "2000-01-23T04:56:07.000+00:00",
  "totalItems" : 6,
  "configuration" : {
    "key" : ""
  },
  "startedAt" : "2000-01-23T04:56:07.000+00:00",
  "pausedAt" : "2000-01-23T04:56:07.000+00:00",
  "failedAt" : "2000-01-23T04:56:07.000+00:00",
  "progressPercentage" : 0.8008282,
  "failedItems" : 5,
  "metrics" : {
    "key" : ""
  },
  "processedItems" : 1,
  "status" : "not_started",
  "successfulItems" : 5,
  "errorDetails" : {
    "key" : ""
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 
final PhaseExecutionUpdate phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

try {
    final result = await api_instance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionPut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)
PhaseExecutionUpdate *phaseExecutionUpdate = ; // 

// Update phase execution by phase type
[apiInstance campaignsPhaseExecutionPutWith:campaignId
    phaseType:phaseType
    phaseExecutionUpdate:phaseExecutionUpdate
              completionHandler: ^(campaigns_phase_execution_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 
var phaseExecutionUpdate = ; // {PhaseExecutionUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionPutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)
            var phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

            try {
                // Update phase execution by phase type
                campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionPut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 
$phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

try {
    $result = $api_instance->campaignsPhaseExecutionPut($campaignId, $phaseType, $phaseExecutionUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionPut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 
my $phaseExecutionUpdate = WWW::OPenAPIClient::Object::PhaseExecutionUpdate->new(); # PhaseExecutionUpdate | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionPut(campaignId => $campaignId, phaseType => $phaseType, phaseExecutionUpdate => $phaseExecutionUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionPut: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)
phaseExecutionUpdate =  # PhaseExecutionUpdate | 

try:
    # Update phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_put(campaignId, phaseType, phaseExecutionUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionPut: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String
    let phaseExecutionUpdate = ; // PhaseExecutionUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phaseType*
String
Required
Body parameters
Name Description
phaseExecutionUpdate *

Responses


campaignsPhaseExecutionsList

Get campaign state and phase executions


/campaigns/{campaignId}/phase-executions

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseExecutionsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state and phase executions
[apiInstance campaignsPhaseExecutionsListWith:campaignId
              completionHandler: ^(campaigns_phase_executions_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionsList(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state and phase executions
                campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseExecutionsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state and phase executions
    api_response = api_instance.campaigns_phase_executions_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionsList(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsPhaseStart

Start campaign phase


/campaigns/{campaignId}/phases/{phase}/start

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/start"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStart(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStart: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Start campaign phase
[apiInstance campaignsPhaseStartWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStart(campaignId, phase, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStartExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Start campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStart($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStart: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStart(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStart: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Start campaign phase
    api_response = api_instance.campaigns_phase_start(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStart: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStart(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required

Responses


campaignsPhaseStatus

Get phase status


/campaigns/{campaignId}/phases/{phase}/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStatus(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Get phase status
[apiInstance campaignsPhaseStatusWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStatus(campaignId, phase, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Get phase status
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStatus($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStatus(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Get phase status
    api_response = api_instance.campaigns_phase_status(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStatus: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStatus(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required

Responses


campaignsPhaseStop

Stop campaign phase


/campaigns/{campaignId}/phases/{phase}/stop

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/stop"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStop(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStop: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Stop campaign phase
[apiInstance campaignsPhaseStopWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStop(campaignId, phase, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStopExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Stop campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStop: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStop($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStop: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStop(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStop: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Stop campaign phase
    api_response = api_instance.campaigns_phase_stop(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStop: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStop(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required

Responses


campaignsProgress

Get campaign progress


/campaigns/{campaignId}/progress

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/progress"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsProgress(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsProgress: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign progress
[apiInstance campaignsProgressWith:campaignId
              completionHandler: ^(campaigns_progress_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsProgress(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsProgressExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign progress
                campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsProgress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsProgress($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsProgress: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsProgress(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsProgress: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign progress
    api_response = api_instance.campaigns_progress(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsProgress: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsProgress(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsRecommendationsGet

Get campaign recommendations


/campaigns/{campaignId}/insights/recommendations

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/insights/recommendations"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_recommendations_get_200_response result = apiInstance.campaignsRecommendationsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsRecommendationsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsRecommendationsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsRecommendationsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_recommendations_get_200_response result = apiInstance.campaignsRecommendationsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsRecommendationsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign recommendations
[apiInstance campaignsRecommendationsGetWith:campaignId
              completionHandler: ^(campaigns_recommendations_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsRecommendationsGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsRecommendationsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign recommendations
                campaigns_recommendations_get_200_response result = apiInstance.campaignsRecommendationsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsRecommendationsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsRecommendationsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsRecommendationsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsRecommendationsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsRecommendationsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign recommendations
    api_response = api_instance.campaigns_recommendations_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsRecommendationsGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsRecommendationsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsStateDelete

Delete campaign state


/campaigns/{campaignId}/state

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/state"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign state
[apiInstance campaignsStateDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsStateDelete(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign state
                apiInstance.campaignsStateDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsStateDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsStateDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign state
    api_instance.campaigns_state_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateDelete: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsStateGet

Get campaign state


/campaigns/{campaignId}/state

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/state"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state
[apiInstance campaignsStateGetWith:campaignId
              completionHandler: ^(campaigns_state_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStateGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state
                campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsStateGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsStateGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state
    api_response = api_instance.campaigns_state_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsStatePut

Update campaign state


/campaigns/{campaignId}/state

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/state" \
 -d '{
  "mode" : "full_sequence",
  "configuration" : {
    "key" : ""
  },
  "currentState" : "draft",
  "version" : 0
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignStateUpdate campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

try {
    final result = await api_instance.campaignsStatePut(campaignId, campaignStateUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStatePut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignStateUpdate *campaignStateUpdate = ; // 

// Update campaign state
[apiInstance campaignsStatePutWith:campaignId
    campaignStateUpdate:campaignStateUpdate
              completionHandler: ^(campaigns_state_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignStateUpdate = ; // {CampaignStateUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStatePut(campaignId, campaignStateUpdate, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStatePutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

            try {
                // Update campaign state
                campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStatePut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignStateUpdate = ; // CampaignStateUpdate | 

try {
    $result = $api_instance->campaignsStatePut($campaignId, $campaignStateUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStatePut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignStateUpdate = WWW::OPenAPIClient::Object::CampaignStateUpdate->new(); # CampaignStateUpdate | 

eval {
    my $result = $api_instance->campaignsStatePut(campaignId => $campaignId, campaignStateUpdate => $campaignStateUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStatePut: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignStateUpdate =  # CampaignStateUpdate | 

try:
    # Update campaign state
    api_response = api_instance.campaigns_state_put(campaignId, campaignStateUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStatePut: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignStateUpdate = ; // CampaignStateUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStatePut(campaignId, campaignStateUpdate, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
campaignStateUpdate *

Responses


campaignsStatusGet

Get consolidated campaign phase statuses


/campaigns/{campaignId}/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_status_get_200_response result = apiInstance.campaignsStatusGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatusGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStatusGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStatusGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_status_get_200_response result = apiInstance.campaignsStatusGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatusGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get consolidated campaign phase statuses
[apiInstance campaignsStatusGetWith:campaignId
              completionHandler: ^(campaigns_status_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStatusGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStatusGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get consolidated campaign phase statuses
                campaigns_status_get_200_response result = apiInstance.campaignsStatusGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStatusGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsStatusGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStatusGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsStatusGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStatusGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get consolidated campaign phase statuses
    api_response = api_instance.campaigns_status_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStatusGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStatusGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsUpdate

Update campaign


/campaigns/{campaignId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}" \
 -d '{
  "configuration" : "{}",
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final UpdateCampaignRequest updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

try {
    final result = await api_instance.campaignsUpdate(campaignId, updateCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateCampaignRequest *updateCampaignRequest = ; // 

// Update campaign
[apiInstance campaignsUpdateWith:campaignId
    updateCampaignRequest:updateCampaignRequest
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateCampaignRequest = ; // {UpdateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsUpdate(campaignId, updateCampaignRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

            try {
                // Update campaign
                campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateCampaignRequest = ; // UpdateCampaignRequest | 

try {
    $result = $api_instance->campaignsUpdate($campaignId, $updateCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateCampaignRequest = WWW::OPenAPIClient::Object::UpdateCampaignRequest->new(); # UpdateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsUpdate(campaignId => $campaignId, updateCampaignRequest => $updateCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateCampaignRequest =  # UpdateCampaignRequest | 

try:
    # Update campaign
    api_response = api_instance.campaigns_update(campaignId, updateCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsUpdate: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateCampaignRequest = ; // UpdateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsUpdate(campaignId, updateCampaignRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
updateCampaignRequest *

Responses


cancelBulkOperation

Cancel bulk operation


/campaigns/bulk/operations/{operationId}/cancel

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/operations/{operationId}/cancel"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID to cancel

try {
    final result = await api_instance.cancelBulkOperation(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cancelBulkOperation: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID to cancel (default to null)

// Cancel bulk operation
[apiInstance cancelBulkOperationWith:operationId
              completionHandler: ^(cancelBulkOperation_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID to cancel

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancelBulkOperation(operationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cancelBulkOperationExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID to cancel (default to null)

            try {
                // Cancel bulk operation
                cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.cancelBulkOperation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

try {
    $result = $api_instance->cancelBulkOperation($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->cancelBulkOperation: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID to cancel

eval {
    my $result = $api_instance->cancelBulkOperation(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->cancelBulkOperation: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID to cancel (default to null)

try:
    # Cancel bulk operation
    api_response = api_instance.cancel_bulk_operation(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->cancelBulkOperation: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.cancelBulkOperation(operationId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
operationId*
UUID (uuid)
Bulk operation ID to cancel
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


getBulkOperationStatus

Get bulk operation status


/campaigns/bulk/operations/{operationId}/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/operations/{operationId}/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID

try {
    final result = await api_instance.getBulkOperationStatus(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkOperationStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID (default to null)

// Get bulk operation status
[apiInstance getBulkOperationStatusWith:operationId
              completionHandler: ^(getBulkOperationStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkOperationStatus(operationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkOperationStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID (default to null)

            try {
                // Get bulk operation status
                getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkOperationStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

try {
    $result = $api_instance->getBulkOperationStatus($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkOperationStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID

eval {
    my $result = $api_instance->getBulkOperationStatus(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkOperationStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID (default to null)

try:
    # Get bulk operation status
    api_response = api_instance.get_bulk_operation_status(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkOperationStatus: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkOperationStatus(operationId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
operationId*
UUID (uuid)
Bulk operation ID
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


getBulkResourceStatus

Get bulk resource allocation status


/campaigns/bulk/resources/status/{allocationId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/resources/status/{allocationId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID allocationId = new UUID(); // UUID | Resource allocation ID

try {
    final result = await api_instance.getBulkResourceStatus(allocationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkResourceStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Resource allocation ID (default to null)

// Get bulk resource allocation status
[apiInstance getBulkResourceStatusWith:allocationId
              completionHandler: ^(getBulkResourceStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Resource allocation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkResourceStatus(allocationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkResourceStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Resource allocation ID (default to null)

            try {
                // Get bulk resource allocation status
                getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkResourceStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

try {
    $result = $api_instance->getBulkResourceStatus($allocationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkResourceStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Resource allocation ID

eval {
    my $result = $api_instance->getBulkResourceStatus(allocationId => $allocationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkResourceStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Resource allocation ID (default to null)

try:
    # Get bulk resource allocation status
    api_response = api_instance.get_bulk_resource_status(allocationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkResourceStatus: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkResourceStatus(allocationId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
allocationId*
UUID (uuid)
Resource allocation ID
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Database

dbBulkQuery

Execute bulk database queries


/database/query

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/database/query" \
 -d '{
  "limit" : 0,
  "queries" : [ {
    "id" : "id",
    "sql" : "sql"
  }, {
    "id" : "id",
    "sql" : "sql"
  } ],
  "timeout" : 6
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseQueryRequest bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkQuery: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseQueryRequest *bulkDatabaseQueryRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Execute bulk database queries
[apiInstance dbBulkQueryWith:bulkDatabaseQueryRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(db_bulk_query_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseQueryRequest = ; // {BulkDatabaseQueryRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkQuery(bulkDatabaseQueryRequest, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Execute bulk database queries
                db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkQuery: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkQuery($bulkDatabaseQueryRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseQueryRequest = WWW::OPenAPIClient::Object::BulkDatabaseQueryRequest->new(); # BulkDatabaseQueryRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkQuery(bulkDatabaseQueryRequest => $bulkDatabaseQueryRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkQuery: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseQueryRequest =  # BulkDatabaseQueryRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Execute bulk database queries
    api_response = api_instance.db_bulk_query(bulkDatabaseQueryRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkQuery: %s\n" % e)
extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Requested-With
String
CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
Body parameters
Name Description
bulkDatabaseQueryRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


dbBulkStats

Get bulk database statistics

Retrieve comprehensive database statistics including schema and table-level details


/database/stats

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/database/stats" \
 -d '{
  "tables" : [ "tables", "tables" ],
  "schemas" : [ "schemas", "schemas" ],
  "includeIndexes" : true,
  "includeSize" : true
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseStatsRequest bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkStats: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseStatsRequest *bulkDatabaseStatsRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Get bulk database statistics
[apiInstance dbBulkStatsWith:bulkDatabaseStatsRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(db_bulk_stats_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseStatsRequest = ; // {BulkDatabaseStatsRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkStats(bulkDatabaseStatsRequest, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Get bulk database statistics
                db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkStats($bulkDatabaseStatsRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseStatsRequest = WWW::OPenAPIClient::Object::BulkDatabaseStatsRequest->new(); # BulkDatabaseStatsRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkStats(bulkDatabaseStatsRequest => $bulkDatabaseStatsRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseStatsRequest =  # BulkDatabaseStatsRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Get bulk database statistics
    api_response = api_instance.db_bulk_stats(bulkDatabaseStatsRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkStats: %s\n" % e)
extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Requested-With
String
CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
Body parameters
Name Description
bulkDatabaseStatsRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


FeatureFlags

featureFlagsGet

Get feature flags


/config/features

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/features"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FeatureFlagsApi;

import java.io.File;
import java.util.*;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.featureFlagsGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->featureFlagsGet: $e\n');
}

import org.openapitools.client.api.FeatureFlagsApi;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
FeatureFlagsApi *apiInstance = [[FeatureFlagsApi alloc] init];

// Get feature flags
[apiInstance featureFlagsGetWithCompletionHandler: 
              ^(feature_flags_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.FeatureFlagsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.featureFlagsGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class featureFlagsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new FeatureFlagsApi();

            try {
                // Get feature flags
                feature_flags_get_200_response result = apiInstance.featureFlagsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeatureFlagsApi.featureFlagsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeatureFlagsApi();

try {
    $result = $api_instance->featureFlagsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeatureFlagsApi->featureFlagsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FeatureFlagsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeatureFlagsApi->new();

eval {
    my $result = $api_instance->featureFlagsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeatureFlagsApi->featureFlagsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.FeatureFlagsApi()

try:
    # Get feature flags
    api_response = api_instance.feature_flags_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeatureFlagsApi->featureFlagsGet: %s\n" % e)
extern crate FeatureFlagsApi;

pub fn main() {

    let mut context = FeatureFlagsApi::Context::default();
    let result = client.featureFlagsGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


featureFlagsUpdate

Update feature flags


/config/features

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/features" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FeatureFlagsApi;

import java.io.File;
import java.util.*;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, Boolean] requestBody = new map[String, Boolean](); // map[String, Boolean] | 

try {
    final result = await api_instance.featureFlagsUpdate(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->featureFlagsUpdate: $e\n');
}

import org.openapitools.client.api.FeatureFlagsApi;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
FeatureFlagsApi *apiInstance = [[FeatureFlagsApi alloc] init];
map[String, Boolean] *requestBody = Object; // 

// Update feature flags
[apiInstance featureFlagsUpdateWith:requestBody
              completionHandler: ^(feature_flags_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.FeatureFlagsApi()
var requestBody = Object; // {map[String, Boolean]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.featureFlagsUpdate(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class featureFlagsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new FeatureFlagsApi();
            var requestBody = new map[String, Boolean](); // map[String, Boolean] | 

            try {
                // Update feature flags
                feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeatureFlagsApi.featureFlagsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeatureFlagsApi();
$requestBody = Object; // map[String, Boolean] | 

try {
    $result = $api_instance->featureFlagsUpdate($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeatureFlagsApi->featureFlagsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FeatureFlagsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeatureFlagsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, Boolean]->new(); # map[String, Boolean] | 

eval {
    my $result = $api_instance->featureFlagsUpdate(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeatureFlagsApi->featureFlagsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.FeatureFlagsApi()
requestBody = Object # map[String, Boolean] | 

try:
    # Update feature flags
    api_response = api_instance.feature_flags_update(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeatureFlagsApi->featureFlagsUpdate: %s\n" % e)
extern crate FeatureFlagsApi;

pub fn main() {
    let requestBody = Object; // map[String, Boolean]

    let mut context = FeatureFlagsApi::Context::default();
    let result = client.featureFlagsUpdate(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Health

healthCheck

Health check


/health

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/health"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthCheck();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthCheck: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Health check
[apiInstance healthCheckWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthCheck(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthCheckExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Health check
                SuccessEnvelope result = apiInstance.healthCheck();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthCheck: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthCheck();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthCheck: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthCheck();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthCheck: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Health check
    api_response = api_instance.health_check()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthCheck: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthCheck(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


healthLive

Liveness check


/health/live

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/health/live"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthLive();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthLive: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Liveness check
[apiInstance healthLiveWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthLive(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthLiveExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Liveness check
                SuccessEnvelope result = apiInstance.healthLive();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthLive: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthLive();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthLive: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthLive();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthLive: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Liveness check
    api_response = api_instance.health_live()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthLive: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthLive(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


healthReady

Readiness check


/health/ready

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/health/ready"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthReady();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthReady: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Readiness check
[apiInstance healthReadyWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthReady(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthReadyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Readiness check
                SuccessEnvelope result = apiInstance.healthReady();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthReady: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthReady();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthReady: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthReady();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthReady: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Readiness check
    api_response = api_instance.health_ready()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthReady: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthReady(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


ping

Ping server


/ping

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/ping"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.ping();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->ping: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Ping server
[apiInstance pingWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ping(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Ping server
                SuccessEnvelope result = apiInstance.ping();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.ping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->ping();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->ping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->ping();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->ping: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Ping server
    api_response = api_instance.ping()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->ping: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.ping(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


KeywordExtraction

keywordExtractBatch

Batch keyword extraction


/extract/keywords

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/extract/keywords" \
 -d '{
  "items" : [ {
    "httpPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "keywordSetId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "dnsPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "url" : "https://openapi-generator.tech"
  }, {
    "httpPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "keywordSetId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "dnsPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "url" : "https://openapi-generator.tech"
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BatchKeywordExtractionRequest batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

try {
    final result = await api_instance.keywordExtractBatch(batchKeywordExtractionRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractBatch: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
BatchKeywordExtractionRequest *batchKeywordExtractionRequest = ; // 

// Batch keyword extraction
[apiInstance keywordExtractBatchWith:batchKeywordExtractionRequest
              completionHandler: ^(keyword_extract_batch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var batchKeywordExtractionRequest = ; // {BatchKeywordExtractionRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractBatch(batchKeywordExtractionRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractBatchExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

            try {
                // Batch keyword extraction
                keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

try {
    $result = $api_instance->keywordExtractBatch($batchKeywordExtractionRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractBatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $batchKeywordExtractionRequest = WWW::OPenAPIClient::Object::BatchKeywordExtractionRequest->new(); # BatchKeywordExtractionRequest | 

eval {
    my $result = $api_instance->keywordExtractBatch(batchKeywordExtractionRequest => $batchKeywordExtractionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractBatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
batchKeywordExtractionRequest =  # BatchKeywordExtractionRequest | 

try:
    # Batch keyword extraction
    api_response = api_instance.keyword_extract_batch(batchKeywordExtractionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractBatch: %s\n" % e)
extern crate KeywordExtractionApi;

pub fn main() {
    let batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractBatch(batchKeywordExtractionRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
batchKeywordExtractionRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordExtractStream

Stream keyword extraction

Server-Sent Events stream. Clients SHOULD handle heartbeats and reconnection hints. Heartbeat events are sent periodically: - see example SseHeartbeat; clients SHOULD keep the connection alive. The server MAY suggest a retry delay with an SSE control line (see SseRetry example).


/extract/keywords/stream

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: text/event-stream,application/json" \
 "https://api.domainflow.dev/api/v2/extract/keywords/stream?url=url_example&keywordSetId=38400000-8cf0-11bd-b23e-10b96e4ef00d&httpPersonaId=38400000-8cf0-11bd-b23e-10b96e4ef00d&dnsPersonaId=38400000-8cf0-11bd-b23e-10b96e4ef00d"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final URI url = new URI(); // URI | 
final UUID keywordSetId = new UUID(); // UUID | 
final UUID httpPersonaId = new UUID(); // UUID | 
final UUID dnsPersonaId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractStream: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
URI *url = url_example; //  (default to null)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
UUID *dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)

// Stream keyword extraction
[apiInstance keywordExtractStreamWith:url
    keywordSetId:keywordSetId
    httpPersonaId:httpPersonaId
    dnsPersonaId:dnsPersonaId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var url = url_example; // {URI} 
var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'httpPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'dnsPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d // {UUID} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractStream(url, keywordSetId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractStreamExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var url = url_example;  // URI |  (default to null)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)

            try {
                // Stream keyword extraction
                'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractStream: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$url = url_example; // URI | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordExtractStream($url, $keywordSetId, $httpPersonaId, $dnsPersonaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractStream: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $url = url_example; # URI | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordExtractStream(url => $url, keywordSetId => $keywordSetId, httpPersonaId => $httpPersonaId, dnsPersonaId => $dnsPersonaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractStream: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
url = url_example # URI |  (default to null)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)

try:
    # Stream keyword extraction
    api_response = api_instance.keyword_extract_stream(url, keywordSetId, httpPersonaId=httpPersonaId, dnsPersonaId=dnsPersonaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractStream: %s\n" % e)
extern crate KeywordExtractionApi;

pub fn main() {
    let url = url_example; // URI
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
url*
URI (uri)
Required
keywordSetId*
UUID (uuid)
Required
httpPersonaId
UUID (uuid)
dnsPersonaId
UUID (uuid)

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


KeywordRules

keywordRulesQuery

Query keyword rules


/keyword-rules

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-rules?limit=56&offset=56&keyword_set_id=38400000-8cf0-11bd-b23e-10b96e4ef00d&rule_type=&category=category_example&is_case_sensitive=true&pattern=pattern_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordRulesApi;

import java.io.File;
import java.util.*;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final UUID keywordSetId = new UUID(); // UUID | 
final KeywordRuleType ruleType = new KeywordRuleType(); // KeywordRuleType | 
final String category = new String(); // String | 
final Boolean isCaseSensitive = new Boolean(); // Boolean | 
final String pattern = new String(); // String | 

try {
    final result = await api_instance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordRulesQuery: $e\n');
}

import org.openapitools.client.api.KeywordRulesApi;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordRulesApi *apiInstance = [[KeywordRulesApi alloc] init];
Integer *limit = 56; //  (optional) (default to 50)
Integer *offset = 56; //  (optional) (default to 0)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
KeywordRuleType *ruleType = ; //  (optional) (default to null)
String *category = category_example; //  (optional) (default to null)
Boolean *isCaseSensitive = true; //  (optional) (default to null)
String *pattern = pattern_example; //  (optional) (default to null)

// Query keyword rules
[apiInstance keywordRulesQueryWith:limit
    offset:offset
    keywordSetId:keywordSetId
    ruleType:ruleType
    category:category
    isCaseSensitive:isCaseSensitive
    pattern:pattern
              completionHandler: ^(keyword_sets_rules_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordRulesApi()
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'keywordSetId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'ruleType': , // {KeywordRuleType} 
  'category': category_example, // {String} 
  'isCaseSensitive': true, // {Boolean} 
  'pattern': pattern_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordRulesQuery(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordRulesQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordRulesApi();
            var limit = 56;  // Integer |  (optional)  (default to 50)
            var offset = 56;  // Integer |  (optional)  (default to 0)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var ruleType = new KeywordRuleType(); // KeywordRuleType |  (optional)  (default to null)
            var category = category_example;  // String |  (optional)  (default to null)
            var isCaseSensitive = true;  // Boolean |  (optional)  (default to null)
            var pattern = pattern_example;  // String |  (optional)  (default to null)

            try {
                // Query keyword rules
                keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordRulesApi.keywordRulesQuery: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordRulesApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$ruleType = ; // KeywordRuleType | 
$category = category_example; // String | 
$isCaseSensitive = true; // Boolean | 
$pattern = pattern_example; // String | 

try {
    $result = $api_instance->keywordRulesQuery($limit, $offset, $keywordSetId, $ruleType, $category, $isCaseSensitive, $pattern);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordRulesApi->keywordRulesQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordRulesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordRulesApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $ruleType = ; # KeywordRuleType | 
my $category = category_example; # String | 
my $isCaseSensitive = true; # Boolean | 
my $pattern = pattern_example; # String | 

eval {
    my $result = $api_instance->keywordRulesQuery(limit => $limit, offset => $offset, keywordSetId => $keywordSetId, ruleType => $ruleType, category => $category, isCaseSensitive => $isCaseSensitive, pattern => $pattern);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordRulesApi->keywordRulesQuery: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordRulesApi()
limit = 56 # Integer |  (optional) (default to 50)
offset = 56 # Integer |  (optional) (default to 0)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
ruleType =  # KeywordRuleType |  (optional) (default to null)
category = category_example # String |  (optional) (default to null)
isCaseSensitive = true # Boolean |  (optional) (default to null)
pattern = pattern_example # String |  (optional) (default to null)

try:
    # Query keyword rules
    api_response = api_instance.keyword_rules_query(limit=limit, offset=offset, keywordSetId=keywordSetId, ruleType=ruleType, category=category, isCaseSensitive=isCaseSensitive, pattern=pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordRulesApi->keywordRulesQuery: %s\n" % e)
extern crate KeywordRulesApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let ruleType = ; // KeywordRuleType
    let category = category_example; // String
    let isCaseSensitive = true; // Boolean
    let pattern = pattern_example; // String

    let mut context = KeywordRulesApi::Context::default();
    let result = client.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
keyword_set_id
UUID (uuid)
rule_type
KeywordRuleType
category
String
is_case_sensitive
Boolean
pattern
String

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


KeywordSets

keywordSetsCreate

Create keyword set


/keyword-sets

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets" \
 -d '{
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "rules" : [ {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  }, {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateKeywordSetRequest createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsCreate(createKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsCreate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
CreateKeywordSetRequest *createKeywordSetRequest = ; // 

// Create keyword set
[apiInstance keywordSetsCreateWith:createKeywordSetRequest
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var createKeywordSetRequest = ; // {CreateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsCreate(createKeywordSetRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

            try {
                // Create keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$createKeywordSetRequest = ; // CreateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsCreate($createKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $createKeywordSetRequest = WWW::OPenAPIClient::Object::CreateKeywordSetRequest->new(); # CreateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsCreate(createKeywordSetRequest => $createKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
createKeywordSetRequest =  # CreateKeywordSetRequest | 

try:
    # Create keyword set
    api_response = api_instance.keyword_sets_create(createKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsCreate: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let createKeywordSetRequest = ; // CreateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsCreate(createKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createKeywordSetRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsDelete

Delete keyword set


/keyword-sets/{setId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsDelete(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsDelete: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete keyword set
[apiInstance keywordSetsDeleteWith:setId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.keywordSetsDelete(setId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete keyword set
                apiInstance.keywordSetsDelete(setId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->keywordSetsDelete($setId);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->keywordSetsDelete(setId => $setId);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete keyword set
    api_instance.keyword_sets_delete(setId)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsDelete: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsDelete(setId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsGet

Get keyword set


/keyword-sets/{setId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsGet(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsGet: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get keyword set
[apiInstance keywordSetsGetWith:setId
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsGet(setId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordSetsGet($setId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordSetsGet(setId => $setId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get keyword set
    api_response = api_instance.keyword_sets_get(setId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsGet: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsGet(setId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsList

List keyword sets


/keyword-sets

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets?limit=56&offset=56&includeRules=true&isEnabled=true"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
        Boolean isEnabled = true; // Boolean | Filter by enabled state

        try {
            keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final Boolean includeRules = new Boolean(); // Boolean | If true, include rules array in keyword-sets list items
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state

try {
    final result = await api_instance.keywordSetsList(limit, offset, includeRules, isEnabled);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsList: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
        Boolean isEnabled = true; // Boolean | Filter by enabled state

        try {
            keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
Boolean *includeRules = true; // If true, include rules array in keyword-sets list items (optional) (default to null)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)

// List keyword sets
[apiInstance keywordSetsListWith:limit
    offset:offset
    includeRules:includeRules
    isEnabled:isEnabled
              completionHandler: ^(keyword_sets_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'includeRules': true, // {Boolean} If true, include rules array in keyword-sets list items
  'isEnabled': true // {Boolean} Filter by enabled state
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var includeRules = true;  // Boolean | If true, include rules array in keyword-sets list items (optional)  (default to null)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)

            try {
                // List keyword sets
                keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
$isEnabled = true; // Boolean | Filter by enabled state

try {
    $result = $api_instance->keywordSetsList($limit, $offset, $includeRules, $isEnabled);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $includeRules = true; # Boolean | If true, include rules array in keyword-sets list items
my $isEnabled = true; # Boolean | Filter by enabled state

eval {
    my $result = $api_instance->keywordSetsList(limit => $limit, offset => $offset, includeRules => $includeRules, isEnabled => $isEnabled);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
includeRules = true # Boolean | If true, include rules array in keyword-sets list items (optional) (default to null)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)

try:
    # List keyword sets
    api_response = api_instance.keyword_sets_list(limit=limit, offset=offset, includeRules=includeRules, isEnabled=isEnabled)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsList: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let includeRules = true; // Boolean
    let isEnabled = true; // Boolean

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsList(limit, offset, includeRules, isEnabled, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset
includeRules
Boolean
If true, include rules array in keyword-sets list items
isEnabled
Boolean
Filter by enabled state

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsRulesList

List rules for a keyword set


/keyword-sets/{setId}/rules

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}/rules"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsRulesList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsRulesList(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsRulesList: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsRulesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List rules for a keyword set
[apiInstance keywordSetsRulesListWith:setId
              completionHandler: ^(keyword_sets_rules_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsRulesList(setId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsRulesListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List rules for a keyword set
                keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsRulesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordSetsRulesList($setId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsRulesList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordSetsRulesList(setId => $setId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsRulesList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List rules for a keyword set
    api_response = api_instance.keyword_sets_rules_list(setId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsRulesList: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsRulesList(setId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsUpdate

Update keyword set


/keyword-sets/{setId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}" \
 -d '{
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "rules" : [ {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  }, {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateKeywordSetRequest updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 
final UpdateKeywordSetRequest updateKeywordSetRequest = new UpdateKeywordSetRequest(); // UpdateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsUpdate(setId, updateKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsUpdate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateKeywordSetRequest updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateKeywordSetRequest *updateKeywordSetRequest = ; // 

// Update keyword set
[apiInstance keywordSetsUpdateWith:setId
    updateKeywordSetRequest:updateKeywordSetRequest
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateKeywordSetRequest = ; // {UpdateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsUpdate(setId, updateKeywordSetRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateKeywordSetRequest = new UpdateKeywordSetRequest(); // UpdateKeywordSetRequest | 

            try {
                // Update keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsUpdate($setId, $updateKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateKeywordSetRequest = WWW::OPenAPIClient::Object::UpdateKeywordSetRequest->new(); # UpdateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsUpdate(setId => $setId, updateKeywordSetRequest => $updateKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateKeywordSetRequest =  # UpdateKeywordSetRequest | 

try:
    # Update keyword set
    api_response = api_instance.keyword_sets_update(setId, updateKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsUpdate: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateKeywordSetRequest = ; // UpdateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsUpdate(setId, updateKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required
Body parameters
Name Description
updateKeywordSetRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Monitoring

monitoringCampaignGeneric

Monitoring campaign-specific endpoint


/monitoring/cleanup/campaigns/{campaignId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/cleanup/campaigns/{campaignId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignGeneric");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignGeneric(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignGeneric: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignGeneric");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign-specific endpoint
[apiInstance monitoringCampaignGenericWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignGeneric(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignGenericExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign-specific endpoint
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignGeneric: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignGeneric($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignGeneric: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignGeneric(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignGeneric: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign-specific endpoint
    api_response = api_instance.monitoring_campaign_generic(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignGeneric: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignGeneric(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCampaignHealth

Monitoring campaign health


/monitoring/campaigns/{campaignId}/health

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/health"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignHealth(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignHealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignHealth(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignHealth: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignHealth(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignHealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign health
[apiInstance monitoringCampaignHealthWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignHealth(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignHealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign health
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignHealth(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignHealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignHealth($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignHealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignHealth(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignHealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign health
    api_response = api_instance.monitoring_campaign_health(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignHealth: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignHealth(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCampaignLimits

Set campaign resource limits


/monitoring/campaigns/{campaignId}/limits

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/limits" \
 -d '{
  "maxMemoryMB" : 0,
  "maxConcurrentJobs" : 0,
  "maxDurationSeconds" : 0,
  "maxCPUPercent" : 14.65813,
  "rateLimitPerMinute" : 0,
  "maxDiskMB" : 0
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        MonitoringCampaignLimitsRequest monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest | 

        try {
            apiInstance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignLimits");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final MonitoringCampaignLimitsRequest monitoringCampaignLimitsRequest = new MonitoringCampaignLimitsRequest(); // MonitoringCampaignLimitsRequest | 

try {
    final result = await api_instance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignLimits: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        MonitoringCampaignLimitsRequest monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest | 

        try {
            apiInstance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignLimits");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
MonitoringCampaignLimitsRequest *monitoringCampaignLimitsRequest = ; // 

// Set campaign resource limits
[apiInstance monitoringCampaignLimitsWith:campaignId
    monitoringCampaignLimitsRequest:monitoringCampaignLimitsRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var monitoringCampaignLimitsRequest = ; // {MonitoringCampaignLimitsRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignLimitsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var monitoringCampaignLimitsRequest = new MonitoringCampaignLimitsRequest(); // MonitoringCampaignLimitsRequest | 

            try {
                // Set campaign resource limits
                apiInstance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignLimits: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest | 

try {
    $api_instance->monitoringCampaignLimits($campaignId, $monitoringCampaignLimitsRequest);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignLimits: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $monitoringCampaignLimitsRequest = WWW::OPenAPIClient::Object::MonitoringCampaignLimitsRequest->new(); # MonitoringCampaignLimitsRequest | 

eval {
    $api_instance->monitoringCampaignLimits(campaignId => $campaignId, monitoringCampaignLimitsRequest => $monitoringCampaignLimitsRequest);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignLimits: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
monitoringCampaignLimitsRequest =  # MonitoringCampaignLimitsRequest | 

try:
    # Set campaign resource limits
    api_instance.monitoring_campaign_limits(campaignId, monitoringCampaignLimitsRequest)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignLimits: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
monitoringCampaignLimitsRequest *

Responses


monitoringCampaignPerformance

Monitoring campaign performance


/monitoring/campaigns/{campaignId}/performance

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/performance"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignPerformance(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignPerformance");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignPerformance(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignPerformance: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignPerformance(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignPerformance");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign performance
[apiInstance monitoringCampaignPerformanceWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignPerformance(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignPerformanceExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign performance
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignPerformance(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignPerformance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignPerformance($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignPerformance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignPerformance(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignPerformance: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign performance
    api_response = api_instance.monitoring_campaign_performance(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignPerformance: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignPerformance(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCampaignResources

Monitoring campaign resources


/monitoring/campaigns/{campaignId}/resources

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/resources"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignResources(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignResources");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignResources(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignResources: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignResources(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignResources");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign resources
[apiInstance monitoringCampaignResourcesWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignResources(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignResourcesExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign resources
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignResources(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignResources: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignResources($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignResources: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignResources(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignResources: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign resources
    api_response = api_instance.monitoring_campaign_resources(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignResources: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignResources(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCleanupForce

Force cleanup


/monitoring/cleanup/campaigns/{campaignId}/force

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/cleanup/campaigns/{campaignId}/force"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.monitoringCleanupForce(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupForce");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCleanupForce(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCleanupForce: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.monitoringCleanupForce(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupForce");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Force cleanup
[apiInstance monitoringCleanupForceWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.monitoringCleanupForce(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCleanupForceExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Force cleanup
                apiInstance.monitoringCleanupForce(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCleanupForce: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->monitoringCleanupForce($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCleanupForce: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->monitoringCleanupForce(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCleanupForce: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Force cleanup
    api_instance.monitoring_cleanup_force(campaignId)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCleanupForce: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCleanupForce(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCleanupStats

Cleanup stats


/monitoring/cleanup/stats

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/cleanup/stats"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCleanupStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringCleanupStats();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCleanupStats: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCleanupStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Cleanup stats
[apiInstance monitoringCleanupStatsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCleanupStats(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCleanupStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Cleanup stats
                monitoring_performance_summary_200_response result = apiInstance.monitoringCleanupStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCleanupStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringCleanupStats();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCleanupStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringCleanupStats();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCleanupStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Cleanup stats
    api_response = api_instance.monitoring_cleanup_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCleanupStats: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCleanupStats(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringDashboardSummary

Monitoring dashboard summary


/monitoring/dashboard/summary

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/dashboard/summary"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringDashboardSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringDashboardSummary");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringDashboardSummary();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringDashboardSummary: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringDashboardSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringDashboardSummary");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring dashboard summary
[apiInstance monitoringDashboardSummaryWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringDashboardSummary(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringDashboardSummaryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring dashboard summary
                monitoring_performance_summary_200_response result = apiInstance.monitoringDashboardSummary();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringDashboardSummary: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringDashboardSummary();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringDashboardSummary: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringDashboardSummary();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringDashboardSummary: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring dashboard summary
    api_response = api_instance.monitoring_dashboard_summary()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringDashboardSummary: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringDashboardSummary(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringHealth

Monitoring health


/monitoring/health

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/health"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringHealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringHealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringHealth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringHealth: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringHealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringHealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring health
[apiInstance monitoringHealthWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringHealth(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringHealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring health
                monitoring_performance_summary_200_response result = apiInstance.monitoringHealth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringHealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringHealth();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringHealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringHealth();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringHealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring health
    api_response = api_instance.monitoring_health()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringHealth: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringHealth(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceActive

Monitoring performance active


/monitoring/performance/active

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/active"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceActive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceActive");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceActive();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceActive: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceActive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceActive");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance active
[apiInstance monitoringPerformanceActiveWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceActive(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceActiveExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance active
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceActive();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceActive: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceActive();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceActive: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceActive();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceActive: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance active
    api_response = api_instance.monitoring_performance_active()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceActive: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceActive(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceFailed

Monitoring performance failed


/monitoring/performance/failed

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/failed"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceFailed();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceFailed");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceFailed();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceFailed: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceFailed();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceFailed");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance failed
[apiInstance monitoringPerformanceFailedWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceFailed(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceFailedExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance failed
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceFailed();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceFailed: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceFailed();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceFailed: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceFailed();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceFailed: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance failed
    api_response = api_instance.monitoring_performance_failed()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceFailed: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceFailed(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceMetrics

Monitoring performance metrics


/monitoring/performance/metrics

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/metrics"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceMetrics");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceMetrics();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceMetrics: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceMetrics");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance metrics
[apiInstance monitoringPerformanceMetricsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceMetrics(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceMetricsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance metrics
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceMetrics();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceMetrics: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceMetrics();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceMetrics: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceMetrics();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceMetrics: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance metrics
    api_response = api_instance.monitoring_performance_metrics()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceMetrics: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceMetrics(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceSlow

Monitoring performance slow


/monitoring/performance/slow

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/slow"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSlow();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSlow");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceSlow();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceSlow: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSlow();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSlow");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance slow
[apiInstance monitoringPerformanceSlowWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceSlow(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceSlowExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance slow
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSlow();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceSlow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceSlow();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceSlow: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceSlow();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceSlow: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance slow
    api_response = api_instance.monitoring_performance_slow()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceSlow: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceSlow(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceSummary

Monitoring performance summary


/monitoring/performance/summary

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/summary"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSummary");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceSummary();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceSummary: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSummary");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance summary
[apiInstance monitoringPerformanceSummaryWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceSummary(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceSummaryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance summary
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSummary();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceSummary: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceSummary();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceSummary: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceSummary();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceSummary: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance summary
    api_response = api_instance.monitoring_performance_summary()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceSummary: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceSummary(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceTrends

Monitoring performance trends


/monitoring/dashboard/trends

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/dashboard/trends"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceTrends();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceTrends");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceTrends();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceTrends: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceTrends();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceTrends");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance trends
[apiInstance monitoringPerformanceTrendsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceTrends(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceTrendsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance trends
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceTrends();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceTrends: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceTrends();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceTrends: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceTrends();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceTrends: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance trends
    api_response = api_instance.monitoring_performance_trends()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceTrends: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceTrends(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringResourcesAlerts

System resources alerts


/monitoring/resources/alerts

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/resources/alerts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesAlerts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesAlerts");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringResourcesAlerts();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringResourcesAlerts: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesAlerts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesAlerts");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// System resources alerts
[apiInstance monitoringResourcesAlertsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringResourcesAlerts(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringResourcesAlertsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // System resources alerts
                monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesAlerts();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringResourcesAlerts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringResourcesAlerts();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringResourcesAlerts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringResourcesAlerts();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringResourcesAlerts: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # System resources alerts
    api_response = api_instance.monitoring_resources_alerts()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringResourcesAlerts: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringResourcesAlerts(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringResourcesHistory

System resources history


/monitoring/resources/history

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/resources/history"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesHistory();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesHistory");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringResourcesHistory();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringResourcesHistory: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesHistory();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesHistory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// System resources history
[apiInstance monitoringResourcesHistoryWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringResourcesHistory(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringResourcesHistoryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // System resources history
                monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesHistory();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringResourcesHistory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringResourcesHistory();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringResourcesHistory: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringResourcesHistory();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringResourcesHistory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # System resources history
    api_response = api_instance.monitoring_resources_history()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringResourcesHistory: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringResourcesHistory(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringResourcesSystem

System resources


/monitoring/resources/system

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/resources/system"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesSystem();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesSystem");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringResourcesSystem();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringResourcesSystem: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesSystem();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesSystem");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// System resources
[apiInstance monitoringResourcesSystemWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringResourcesSystem(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringResourcesSystemExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // System resources
                monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesSystem();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringResourcesSystem: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringResourcesSystem();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringResourcesSystem: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringResourcesSystem();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringResourcesSystem: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # System resources
    api_response = api_instance.monitoring_resources_system()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringResourcesSystem: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringResourcesSystem(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringStats

Monitoring stats


/monitoring/stats

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/stats"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringStats();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringStats: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring stats
[apiInstance monitoringStatsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringStats(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring stats
                monitoring_performance_summary_200_response result = apiInstance.monitoringStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringStats();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringStats();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring stats
    api_response = api_instance.monitoring_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringStats: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringStats(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Personas

personasCreate

Create persona


/personas

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/personas" \
 -d '{
  "personaType" : "dns",
  "configDetails" : {
    "key" : ""
  },
  "isEnabled" : true,
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        CreatePersonaRequest createPersonaRequest = ; // CreatePersonaRequest | 

        try {
            PersonaResponse result = apiInstance.personasCreate(createPersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreatePersonaRequest createPersonaRequest = new CreatePersonaRequest(); // CreatePersonaRequest | 

try {
    final result = await api_instance.personasCreate(createPersonaRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasCreate: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        CreatePersonaRequest createPersonaRequest = ; // CreatePersonaRequest | 

        try {
            PersonaResponse result = apiInstance.personasCreate(createPersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
CreatePersonaRequest *createPersonaRequest = ; // 

// Create persona
[apiInstance personasCreateWith:createPersonaRequest
              completionHandler: ^(PersonaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var createPersonaRequest = ; // {CreatePersonaRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasCreate(createPersonaRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var createPersonaRequest = new CreatePersonaRequest(); // CreatePersonaRequest | 

            try {
                // Create persona
                PersonaResponse result = apiInstance.personasCreate(createPersonaRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$createPersonaRequest = ; // CreatePersonaRequest | 

try {
    $result = $api_instance->personasCreate($createPersonaRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $createPersonaRequest = WWW::OPenAPIClient::Object::CreatePersonaRequest->new(); # CreatePersonaRequest | 

eval {
    my $result = $api_instance->personasCreate(createPersonaRequest => $createPersonaRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
createPersonaRequest =  # CreatePersonaRequest | 

try:
    # Create persona
    api_response = api_instance.personas_create(createPersonaRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasCreate: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let createPersonaRequest = ; // CreatePersonaRequest

    let mut context = PersonasApi::Context::default();
    let result = client.personasCreate(createPersonaRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createPersonaRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasDelete

Delete persona


/personas/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaDeleteResponse result = apiInstance.personasDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasDelete: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaDeleteResponse result = apiInstance.personasDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete persona
[apiInstance personasDeleteWith:id
              completionHandler: ^(PersonaDeleteResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasDelete(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete persona
                PersonaDeleteResponse result = apiInstance.personasDelete(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete persona
    api_response = api_instance.personas_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasDelete: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasDelete(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasGet

Get persona by ID


/personas/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaResponse result = apiInstance.personasGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasGet: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaResponse result = apiInstance.personasGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get persona by ID
[apiInstance personasGetWith:id
              completionHandler: ^(PersonaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasGet(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get persona by ID
                PersonaResponse result = apiInstance.personasGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get persona by ID
    api_response = api_instance.personas_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasGet: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasGet(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasGetDns

Get DNS persona by ID


/personas/dns/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/dns/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaResponse result = apiInstance.personasGetDns(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetDns");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasGetDns(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasGetDns: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaResponse result = apiInstance.personasGetDns(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetDns");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get DNS persona by ID
[apiInstance personasGetDnsWith:id
              completionHandler: ^(PersonaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasGetDns(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasGetDnsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get DNS persona by ID
                PersonaResponse result = apiInstance.personasGetDns(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasGetDns: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasGetDns($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasGetDns: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasGetDns(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasGetDns: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get DNS persona by ID
    api_response = api_instance.personas_get_dns(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasGetDns: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasGetDns(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses


personasGetHttp

Get HTTP persona by ID


/personas/http/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/http/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaResponse result = apiInstance.personasGetHttp(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetHttp");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasGetHttp(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasGetHttp: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PersonaResponse result = apiInstance.personasGetHttp(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetHttp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get HTTP persona by ID
[apiInstance personasGetHttpWith:id
              completionHandler: ^(PersonaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasGetHttp(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasGetHttpExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get HTTP persona by ID
                PersonaResponse result = apiInstance.personasGetHttp(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasGetHttp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasGetHttp($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasGetHttp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasGetHttp(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasGetHttp: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get HTTP persona by ID
    api_response = api_instance.personas_get_http(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasGetHttp: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasGetHttp(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses


personasList

List personas


/personas

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas?limit=56&offset=56&isEnabled=true&personaType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        PersonaType personaType = ; // PersonaType | Filter by persona type

        try {
            array[PersonaResponse] result = apiInstance.personasList(limit, offset, isEnabled, personaType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state
final PersonaType personaType = new PersonaType(); // PersonaType | Filter by persona type

try {
    final result = await api_instance.personasList(limit, offset, isEnabled, personaType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasList: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        PersonaType personaType = ; // PersonaType | Filter by persona type

        try {
            array[PersonaResponse] result = apiInstance.personasList(limit, offset, isEnabled, personaType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)
PersonaType *personaType = ; // Filter by persona type (optional) (default to null)

// List personas
[apiInstance personasListWith:limit
    offset:offset
    isEnabled:isEnabled
    personaType:personaType
              completionHandler: ^(array[PersonaResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'isEnabled': true, // {Boolean} Filter by enabled state
  'personaType':  // {PersonaType} Filter by persona type
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)
            var personaType = new PersonaType(); // PersonaType | Filter by persona type (optional)  (default to null)

            try {
                // List personas
                array[PersonaResponse] result = apiInstance.personasList(limit, offset, isEnabled, personaType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$isEnabled = true; // Boolean | Filter by enabled state
$personaType = ; // PersonaType | Filter by persona type

try {
    $result = $api_instance->personasList($limit, $offset, $isEnabled, $personaType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $isEnabled = true; # Boolean | Filter by enabled state
my $personaType = ; # PersonaType | Filter by persona type

eval {
    my $result = $api_instance->personasList(limit => $limit, offset => $offset, isEnabled => $isEnabled, personaType => $personaType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)
personaType =  # PersonaType | Filter by persona type (optional) (default to null)

try:
    # List personas
    api_response = api_instance.personas_list(limit=limit, offset=offset, isEnabled=isEnabled, personaType=personaType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasList: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let isEnabled = true; // Boolean
    let personaType = ; // PersonaType

    let mut context = PersonasApi::Context::default();
    let result = client.personasList(limit, offset, isEnabled, personaType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset
isEnabled
Boolean
Filter by enabled state
personaType
PersonaType
Filter by persona type

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasTest

Test persona


/personas/{id}/test

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}/test"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_test_200_response result = apiInstance.personasTest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasTest");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasTest(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasTest: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_test_200_response result = apiInstance.personasTest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasTest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Test persona
[apiInstance personasTestWith:id
              completionHandler: ^(personas_test_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasTest(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasTestExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Test persona
                personas_test_200_response result = apiInstance.personasTest(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasTest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasTest($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasTest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasTest(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasTest: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Test persona
    api_response = api_instance.personas_test(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasTest: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasTest(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasUpdate

Update persona


/personas/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}" \
 -d '{
  "configDetails" : {
    "key" : ""
  },
  "isEnabled" : true,
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdatePersonaRequest updatePersonaRequest = ; // UpdatePersonaRequest | 

        try {
            PersonaResponse result = apiInstance.personasUpdate(id, updatePersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 
final UpdatePersonaRequest updatePersonaRequest = new UpdatePersonaRequest(); // UpdatePersonaRequest | 

try {
    final result = await api_instance.personasUpdate(id, updatePersonaRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasUpdate: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdatePersonaRequest updatePersonaRequest = ; // UpdatePersonaRequest | 

        try {
            PersonaResponse result = apiInstance.personasUpdate(id, updatePersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdatePersonaRequest *updatePersonaRequest = ; // 

// Update persona
[apiInstance personasUpdateWith:id
    updatePersonaRequest:updatePersonaRequest
              completionHandler: ^(PersonaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updatePersonaRequest = ; // {UpdatePersonaRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasUpdate(id, updatePersonaRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updatePersonaRequest = new UpdatePersonaRequest(); // UpdatePersonaRequest | 

            try {
                // Update persona
                PersonaResponse result = apiInstance.personasUpdate(id, updatePersonaRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updatePersonaRequest = ; // UpdatePersonaRequest | 

try {
    $result = $api_instance->personasUpdate($id, $updatePersonaRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updatePersonaRequest = WWW::OPenAPIClient::Object::UpdatePersonaRequest->new(); # UpdatePersonaRequest | 

eval {
    my $result = $api_instance->personasUpdate(id => $id, updatePersonaRequest => $updatePersonaRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updatePersonaRequest =  # UpdatePersonaRequest | 

try:
    # Update persona
    api_response = api_instance.personas_update(id, updatePersonaRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasUpdate: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updatePersonaRequest = ; // UpdatePersonaRequest

    let mut context = PersonasApi::Context::default();
    let result = client.personasUpdate(id, updatePersonaRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required
Body parameters
Name Description
updatePersonaRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Proxies

proxiesBulkDelete

Bulk delete proxies


/proxies/bulk/delete

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/bulk/delete" \
 -d '{
  "proxyIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        BulkDeleteProxiesRequest bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkDelete(bulkDeleteProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDeleteProxiesRequest bulkDeleteProxiesRequest = new BulkDeleteProxiesRequest(); // BulkDeleteProxiesRequest | 

try {
    final result = await api_instance.proxiesBulkDelete(bulkDeleteProxiesRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesBulkDelete: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        BulkDeleteProxiesRequest bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkDelete(bulkDeleteProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
BulkDeleteProxiesRequest *bulkDeleteProxiesRequest = ; // 

// Bulk delete proxies
[apiInstance proxiesBulkDeleteWith:bulkDeleteProxiesRequest
              completionHandler: ^(proxies_bulk_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var bulkDeleteProxiesRequest = ; // {BulkDeleteProxiesRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesBulkDelete(bulkDeleteProxiesRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesBulkDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var bulkDeleteProxiesRequest = new BulkDeleteProxiesRequest(); // BulkDeleteProxiesRequest | 

            try {
                // Bulk delete proxies
                proxies_bulk_update_200_response result = apiInstance.proxiesBulkDelete(bulkDeleteProxiesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesBulkDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest | 

try {
    $result = $api_instance->proxiesBulkDelete($bulkDeleteProxiesRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesBulkDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $bulkDeleteProxiesRequest = WWW::OPenAPIClient::Object::BulkDeleteProxiesRequest->new(); # BulkDeleteProxiesRequest | 

eval {
    my $result = $api_instance->proxiesBulkDelete(bulkDeleteProxiesRequest => $bulkDeleteProxiesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesBulkDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
bulkDeleteProxiesRequest =  # BulkDeleteProxiesRequest | 

try:
    # Bulk delete proxies
    api_response = api_instance.proxies_bulk_delete(bulkDeleteProxiesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesBulkDelete: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesBulkDelete(bulkDeleteProxiesRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkDeleteProxiesRequest *

Responses


proxiesBulkTest

Bulk test proxies


/proxies/bulk/test

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/bulk/test" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesBulkTestRequest proxiesBulkTestRequest = ; // ProxiesBulkTestRequest | 

        try {
            proxies_bulk_test_200_response result = apiInstance.proxiesBulkTest(proxiesBulkTestRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkTest");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProxiesBulkTestRequest proxiesBulkTestRequest = new ProxiesBulkTestRequest(); // ProxiesBulkTestRequest | 

try {
    final result = await api_instance.proxiesBulkTest(proxiesBulkTestRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesBulkTest: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesBulkTestRequest proxiesBulkTestRequest = ; // ProxiesBulkTestRequest | 

        try {
            proxies_bulk_test_200_response result = apiInstance.proxiesBulkTest(proxiesBulkTestRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkTest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
ProxiesBulkTestRequest *proxiesBulkTestRequest = ; // 

// Bulk test proxies
[apiInstance proxiesBulkTestWith:proxiesBulkTestRequest
              completionHandler: ^(proxies_bulk_test_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxiesBulkTestRequest = ; // {ProxiesBulkTestRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesBulkTest(proxiesBulkTestRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesBulkTestExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxiesBulkTestRequest = new ProxiesBulkTestRequest(); // ProxiesBulkTestRequest | 

            try {
                // Bulk test proxies
                proxies_bulk_test_200_response result = apiInstance.proxiesBulkTest(proxiesBulkTestRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesBulkTest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxiesBulkTestRequest = ; // ProxiesBulkTestRequest | 

try {
    $result = $api_instance->proxiesBulkTest($proxiesBulkTestRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesBulkTest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxiesBulkTestRequest = WWW::OPenAPIClient::Object::ProxiesBulkTestRequest->new(); # ProxiesBulkTestRequest | 

eval {
    my $result = $api_instance->proxiesBulkTest(proxiesBulkTestRequest => $proxiesBulkTestRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesBulkTest: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxiesBulkTestRequest =  # ProxiesBulkTestRequest | 

try:
    # Bulk test proxies
    api_response = api_instance.proxies_bulk_test(proxiesBulkTestRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesBulkTest: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxiesBulkTestRequest = ; // ProxiesBulkTestRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesBulkTest(proxiesBulkTestRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
proxiesBulkTestRequest *

Responses


proxiesBulkUpdate

Bulk update proxies


/proxies/bulk/update

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/bulk/update" \
 -d '{
  "updates" : {
    "protocol" : "http",
    "password" : "password",
    "address" : "address",
    "notes" : "notes",
    "countryCode" : "countryCode",
    "isEnabled" : true,
    "name" : "name",
    "description" : "description",
    "username" : "username"
  },
  "proxyIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        BulkUpdateProxiesRequest bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkUpdateProxiesRequest bulkUpdateProxiesRequest = new BulkUpdateProxiesRequest(); // BulkUpdateProxiesRequest | 

try {
    final result = await api_instance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesBulkUpdate: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        BulkUpdateProxiesRequest bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
BulkUpdateProxiesRequest *bulkUpdateProxiesRequest = ; // 

// Bulk update proxies
[apiInstance proxiesBulkUpdateWith:bulkUpdateProxiesRequest
              completionHandler: ^(proxies_bulk_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var bulkUpdateProxiesRequest = ; // {BulkUpdateProxiesRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesBulkUpdate(bulkUpdateProxiesRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesBulkUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var bulkUpdateProxiesRequest = new BulkUpdateProxiesRequest(); // BulkUpdateProxiesRequest | 

            try {
                // Bulk update proxies
                proxies_bulk_update_200_response result = apiInstance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesBulkUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest | 

try {
    $result = $api_instance->proxiesBulkUpdate($bulkUpdateProxiesRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesBulkUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $bulkUpdateProxiesRequest = WWW::OPenAPIClient::Object::BulkUpdateProxiesRequest->new(); # BulkUpdateProxiesRequest | 

eval {
    my $result = $api_instance->proxiesBulkUpdate(bulkUpdateProxiesRequest => $bulkUpdateProxiesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesBulkUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
bulkUpdateProxiesRequest =  # BulkUpdateProxiesRequest | 

try:
    # Bulk update proxies
    api_response = api_instance.proxies_bulk_update(bulkUpdateProxiesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesBulkUpdate: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesBulkUpdate(bulkUpdateProxiesRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkUpdateProxiesRequest *

Responses


proxiesCreate

Create proxy


/proxies

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies" \
 -d '{
  "protocol" : "http",
  "password" : "password",
  "address" : "address",
  "notes" : "notes",
  "countryCode" : "countryCode",
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        CreateProxyRequestAPI createProxyRequestAPI = ; // CreateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesCreate(createProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateProxyRequestAPI createProxyRequestAPI = new CreateProxyRequestAPI(); // CreateProxyRequestAPI | 

try {
    final result = await api_instance.proxiesCreate(createProxyRequestAPI);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesCreate: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        CreateProxyRequestAPI createProxyRequestAPI = ; // CreateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesCreate(createProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
CreateProxyRequestAPI *createProxyRequestAPI = ; // 

// Create proxy
[apiInstance proxiesCreateWith:createProxyRequestAPI
              completionHandler: ^(proxies_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var createProxyRequestAPI = ; // {CreateProxyRequestAPI} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesCreate(createProxyRequestAPI, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var createProxyRequestAPI = new CreateProxyRequestAPI(); // CreateProxyRequestAPI | 

            try {
                // Create proxy
                proxies_create_201_response result = apiInstance.proxiesCreate(createProxyRequestAPI);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$createProxyRequestAPI = ; // CreateProxyRequestAPI | 

try {
    $result = $api_instance->proxiesCreate($createProxyRequestAPI);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $createProxyRequestAPI = WWW::OPenAPIClient::Object::CreateProxyRequestAPI->new(); # CreateProxyRequestAPI | 

eval {
    my $result = $api_instance->proxiesCreate(createProxyRequestAPI => $createProxyRequestAPI);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
createProxyRequestAPI =  # CreateProxyRequestAPI | 

try:
    # Create proxy
    api_response = api_instance.proxies_create(createProxyRequestAPI)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesCreate: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let createProxyRequestAPI = ; // CreateProxyRequestAPI

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesCreate(createProxyRequestAPI, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createProxyRequestAPI *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


proxiesDelete

Delete proxy


/proxies/{proxyId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            SuccessEnvelope result = apiInstance.proxiesDelete(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxiesDelete(proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesDelete: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            SuccessEnvelope result = apiInstance.proxiesDelete(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete proxy
[apiInstance proxiesDeleteWith:proxyId
              completionHandler: ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesDelete(proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete proxy
                SuccessEnvelope result = apiInstance.proxiesDelete(proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxiesDelete($proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxiesDelete(proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete proxy
    api_response = api_instance.proxies_delete(proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesDelete: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesDelete(proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required

Responses


proxiesHealthCheckAll

Health check all proxies


/proxies/health-check

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/health-check" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesHealthCheckAllRequest proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest | 

        try {
            proxies_health_check_all_202_response result = apiInstance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProxiesHealthCheckAllRequest proxiesHealthCheckAllRequest = new ProxiesHealthCheckAllRequest(); // ProxiesHealthCheckAllRequest | 

try {
    final result = await api_instance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesHealthCheckAll: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesHealthCheckAllRequest proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest | 

        try {
            proxies_health_check_all_202_response result = apiInstance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckAll");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
ProxiesHealthCheckAllRequest *proxiesHealthCheckAllRequest = ; //  (optional)

// Health check all proxies
[apiInstance proxiesHealthCheckAllWith:proxiesHealthCheckAllRequest
              completionHandler: ^(proxies_health_check_all_202_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var opts = {
  'proxiesHealthCheckAllRequest':  // {ProxiesHealthCheckAllRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesHealthCheckAll(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesHealthCheckAllExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxiesHealthCheckAllRequest = new ProxiesHealthCheckAllRequest(); // ProxiesHealthCheckAllRequest |  (optional) 

            try {
                // Health check all proxies
                proxies_health_check_all_202_response result = apiInstance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesHealthCheckAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest | 

try {
    $result = $api_instance->proxiesHealthCheckAll($proxiesHealthCheckAllRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesHealthCheckAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxiesHealthCheckAllRequest = WWW::OPenAPIClient::Object::ProxiesHealthCheckAllRequest->new(); # ProxiesHealthCheckAllRequest | 

eval {
    my $result = $api_instance->proxiesHealthCheckAll(proxiesHealthCheckAllRequest => $proxiesHealthCheckAllRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesHealthCheckAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxiesHealthCheckAllRequest =  # ProxiesHealthCheckAllRequest |  (optional)

try:
    # Health check all proxies
    api_response = api_instance.proxies_health_check_all(proxiesHealthCheckAllRequest=proxiesHealthCheckAllRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesHealthCheckAll: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesHealthCheckAll(proxiesHealthCheckAllRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
proxiesHealthCheckAllRequest

Responses


proxiesHealthCheckSingle

Health check single proxy


/proxies/{proxyId}/health-check

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}/health-check"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_health_check_single_200_response result = apiInstance.proxiesHealthCheckSingle(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckSingle");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxiesHealthCheckSingle(proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesHealthCheckSingle: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_health_check_single_200_response result = apiInstance.proxiesHealthCheckSingle(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckSingle");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Health check single proxy
[apiInstance proxiesHealthCheckSingleWith:proxyId
              completionHandler: ^(proxies_health_check_single_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesHealthCheckSingle(proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesHealthCheckSingleExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Health check single proxy
                proxies_health_check_single_200_response result = apiInstance.proxiesHealthCheckSingle(proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesHealthCheckSingle: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxiesHealthCheckSingle($proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesHealthCheckSingle: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxiesHealthCheckSingle(proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesHealthCheckSingle: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Health check single proxy
    api_response = api_instance.proxies_health_check_single(proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesHealthCheckSingle: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesHealthCheckSingle(proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required

Responses


proxiesList

List proxies


/proxies

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies?limit=56&offset=56&protocol=&countryCode=countryCode_example&isEnabled=true&isHealthy=true"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        ProxyProtocol protocol = ; // ProxyProtocol | Filter proxies by protocol
        String countryCode = countryCode_example; // String | Filter proxies by ISO country code
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        Boolean isHealthy = true; // Boolean | Filter by health status

        try {
            proxies_list_200_response result = apiInstance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final ProxyProtocol protocol = new ProxyProtocol(); // ProxyProtocol | Filter proxies by protocol
final String countryCode = new String(); // String | Filter proxies by ISO country code
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state
final Boolean isHealthy = new Boolean(); // Boolean | Filter by health status

try {
    final result = await api_instance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesList: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        ProxyProtocol protocol = ; // ProxyProtocol | Filter proxies by protocol
        String countryCode = countryCode_example; // String | Filter proxies by ISO country code
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        Boolean isHealthy = true; // Boolean | Filter by health status

        try {
            proxies_list_200_response result = apiInstance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
ProxyProtocol *protocol = ; // Filter proxies by protocol (optional) (default to null)
String *countryCode = countryCode_example; // Filter proxies by ISO country code (optional) (default to null)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)
Boolean *isHealthy = true; // Filter by health status (optional) (default to null)

// List proxies
[apiInstance proxiesListWith:limit
    offset:offset
    protocol:protocol
    countryCode:countryCode
    isEnabled:isEnabled
    isHealthy:isHealthy
              completionHandler: ^(proxies_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'protocol': , // {ProxyProtocol} Filter proxies by protocol
  'countryCode': countryCode_example, // {String} Filter proxies by ISO country code
  'isEnabled': true, // {Boolean} Filter by enabled state
  'isHealthy': true // {Boolean} Filter by health status
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var protocol = new ProxyProtocol(); // ProxyProtocol | Filter proxies by protocol (optional)  (default to null)
            var countryCode = countryCode_example;  // String | Filter proxies by ISO country code (optional)  (default to null)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)
            var isHealthy = true;  // Boolean | Filter by health status (optional)  (default to null)

            try {
                // List proxies
                proxies_list_200_response result = apiInstance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$protocol = ; // ProxyProtocol | Filter proxies by protocol
$countryCode = countryCode_example; // String | Filter proxies by ISO country code
$isEnabled = true; // Boolean | Filter by enabled state
$isHealthy = true; // Boolean | Filter by health status

try {
    $result = $api_instance->proxiesList($limit, $offset, $protocol, $countryCode, $isEnabled, $isHealthy);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $protocol = ; # ProxyProtocol | Filter proxies by protocol
my $countryCode = countryCode_example; # String | Filter proxies by ISO country code
my $isEnabled = true; # Boolean | Filter by enabled state
my $isHealthy = true; # Boolean | Filter by health status

eval {
    my $result = $api_instance->proxiesList(limit => $limit, offset => $offset, protocol => $protocol, countryCode => $countryCode, isEnabled => $isEnabled, isHealthy => $isHealthy);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
protocol =  # ProxyProtocol | Filter proxies by protocol (optional) (default to null)
countryCode = countryCode_example # String | Filter proxies by ISO country code (optional) (default to null)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)
isHealthy = true # Boolean | Filter by health status (optional) (default to null)

try:
    # List proxies
    api_response = api_instance.proxies_list(limit=limit, offset=offset, protocol=protocol, countryCode=countryCode, isEnabled=isEnabled, isHealthy=isHealthy)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesList: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let protocol = ; // ProxyProtocol
    let countryCode = countryCode_example; // String
    let isEnabled = true; // Boolean
    let isHealthy = true; // Boolean

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset
protocol
ProxyProtocol
Filter proxies by protocol
countryCode
String
Filter proxies by ISO country code
isEnabled
Boolean
Filter by enabled state
isHealthy
Boolean
Filter by health status

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


proxiesStatus

Get proxy statuses


/proxies/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();

        try {
            proxies_status_200_response result = apiInstance.proxiesStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.proxiesStatus();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesStatus: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();

        try {
            proxies_status_200_response result = apiInstance.proxiesStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];

// Get proxy statuses
[apiInstance proxiesStatusWithCompletionHandler: 
              ^(proxies_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesStatus(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();

            try {
                // Get proxy statuses
                proxies_status_200_response result = apiInstance.proxiesStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();

try {
    $result = $api_instance->proxiesStatus();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();

eval {
    my $result = $api_instance->proxiesStatus();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()

try:
    # Get proxy statuses
    api_response = api_instance.proxies_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesStatus: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesStatus(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


proxiesTest

Test proxy


/proxies/{proxyId}/test

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}/test"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_test_200_response result = apiInstance.proxiesTest(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesTest");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxiesTest(proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesTest: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_test_200_response result = apiInstance.proxiesTest(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesTest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Test proxy
[apiInstance proxiesTestWith:proxyId
              completionHandler: ^(proxies_test_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesTest(proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesTestExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Test proxy
                proxies_test_200_response result = apiInstance.proxiesTest(proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesTest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxiesTest($proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesTest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxiesTest(proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesTest: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Test proxy
    api_response = api_instance.proxies_test(proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesTest: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesTest(proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


proxiesUpdate

Update proxy


/proxies/{proxyId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}" \
 -d '{
  "protocol" : "http",
  "password" : "password",
  "address" : "address",
  "notes" : "notes",
  "countryCode" : "countryCode",
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateProxyRequestAPI updateProxyRequestAPI = ; // UpdateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesUpdate(proxyId, updateProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 
final UpdateProxyRequestAPI updateProxyRequestAPI = new UpdateProxyRequestAPI(); // UpdateProxyRequestAPI | 

try {
    final result = await api_instance.proxiesUpdate(proxyId, updateProxyRequestAPI);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesUpdate: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateProxyRequestAPI updateProxyRequestAPI = ; // UpdateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesUpdate(proxyId, updateProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateProxyRequestAPI *updateProxyRequestAPI = ; // 

// Update proxy
[apiInstance proxiesUpdateWith:proxyId
    updateProxyRequestAPI:updateProxyRequestAPI
              completionHandler: ^(proxies_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateProxyRequestAPI = ; // {UpdateProxyRequestAPI} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesUpdate(proxyId, updateProxyRequestAPI, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateProxyRequestAPI = new UpdateProxyRequestAPI(); // UpdateProxyRequestAPI | 

            try {
                // Update proxy
                proxies_create_201_response result = apiInstance.proxiesUpdate(proxyId, updateProxyRequestAPI);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateProxyRequestAPI = ; // UpdateProxyRequestAPI | 

try {
    $result = $api_instance->proxiesUpdate($proxyId, $updateProxyRequestAPI);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateProxyRequestAPI = WWW::OPenAPIClient::Object::UpdateProxyRequestAPI->new(); # UpdateProxyRequestAPI | 

eval {
    my $result = $api_instance->proxiesUpdate(proxyId => $proxyId, updateProxyRequestAPI => $updateProxyRequestAPI);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateProxyRequestAPI =  # UpdateProxyRequestAPI | 

try:
    # Update proxy
    api_response = api_instance.proxies_update(proxyId, updateProxyRequestAPI)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesUpdate: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateProxyRequestAPI = ; // UpdateProxyRequestAPI

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesUpdate(proxyId, updateProxyRequestAPI, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required
Body parameters
Name Description
updateProxyRequestAPI *

Responses


ProxyPools

proxyPoolsAddProxy

Add proxy to pool


/proxy-pools/{poolId}/proxies

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}/proxies" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolsAddProxyRequest proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest | 

        try {
            proxy_pools_add_proxy_201_response result = apiInstance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsAddProxy");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 
final ProxyPoolsAddProxyRequest proxyPoolsAddProxyRequest = new ProxyPoolsAddProxyRequest(); // ProxyPoolsAddProxyRequest | 

try {
    final result = await api_instance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsAddProxy: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolsAddProxyRequest proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest | 

        try {
            proxy_pools_add_proxy_201_response result = apiInstance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsAddProxy");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
ProxyPoolsAddProxyRequest *proxyPoolsAddProxyRequest = ; // 

// Add proxy to pool
[apiInstance proxyPoolsAddProxyWith:poolId
    proxyPoolsAddProxyRequest:proxyPoolsAddProxyRequest
              completionHandler: ^(proxy_pools_add_proxy_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var proxyPoolsAddProxyRequest = ; // {ProxyPoolsAddProxyRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsAddProxyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var proxyPoolsAddProxyRequest = new ProxyPoolsAddProxyRequest(); // ProxyPoolsAddProxyRequest | 

            try {
                // Add proxy to pool
                proxy_pools_add_proxy_201_response result = apiInstance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsAddProxy: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest | 

try {
    $result = $api_instance->proxyPoolsAddProxy($poolId, $proxyPoolsAddProxyRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsAddProxy: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $proxyPoolsAddProxyRequest = WWW::OPenAPIClient::Object::ProxyPoolsAddProxyRequest->new(); # ProxyPoolsAddProxyRequest | 

eval {
    my $result = $api_instance->proxyPoolsAddProxy(poolId => $poolId, proxyPoolsAddProxyRequest => $proxyPoolsAddProxyRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsAddProxy: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
proxyPoolsAddProxyRequest =  # ProxyPoolsAddProxyRequest | 

try:
    # Add proxy to pool
    api_response = api_instance.proxy_pools_add_proxy(poolId, proxyPoolsAddProxyRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsAddProxy: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required
Body parameters
Name Description
proxyPoolsAddProxyRequest *

Responses


proxyPoolsCreate

Create proxy pool


/proxy-pools

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools" \
 -d '{
  "healthCheckEnabled" : true,
  "maxRetries" : 6,
  "isEnabled" : true,
  "healthCheckIntervalSeconds" : 0,
  "name" : "name",
  "description" : "description",
  "timeoutSeconds" : 1,
  "poolStrategy" : "poolStrategy"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsCreate(proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProxyPoolRequest proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

try {
    final result = await api_instance.proxyPoolsCreate(proxyPoolRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsCreate: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsCreate(proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
ProxyPoolRequest *proxyPoolRequest = ; // 

// Create proxy pool
[apiInstance proxyPoolsCreateWith:proxyPoolRequest
              completionHandler: ^(proxy_pools_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var proxyPoolRequest = ; // {ProxyPoolRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsCreate(proxyPoolRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

            try {
                // Create proxy pool
                proxy_pools_create_201_response result = apiInstance.proxyPoolsCreate(proxyPoolRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$proxyPoolRequest = ; // ProxyPoolRequest | 

try {
    $result = $api_instance->proxyPoolsCreate($proxyPoolRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $proxyPoolRequest = WWW::OPenAPIClient::Object::ProxyPoolRequest->new(); # ProxyPoolRequest | 

eval {
    my $result = $api_instance->proxyPoolsCreate(proxyPoolRequest => $proxyPoolRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
proxyPoolRequest =  # ProxyPoolRequest | 

try:
    # Create proxy pool
    api_response = api_instance.proxy_pools_create(proxyPoolRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsCreate: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let proxyPoolRequest = ; // ProxyPoolRequest

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsCreate(proxyPoolRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
proxyPoolRequest *

Responses


proxyPoolsDelete

Delete proxy pool


/proxy-pools/{poolId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_delete_200_response result = apiInstance.proxyPoolsDelete(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxyPoolsDelete(poolId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsDelete: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_delete_200_response result = apiInstance.proxyPoolsDelete(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete proxy pool
[apiInstance proxyPoolsDeleteWith:poolId
              completionHandler: ^(proxy_pools_delete_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsDelete(poolId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete proxy pool
                proxy_pools_delete_200_response result = apiInstance.proxyPoolsDelete(poolId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxyPoolsDelete($poolId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxyPoolsDelete(poolId => $poolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete proxy pool
    api_response = api_instance.proxy_pools_delete(poolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsDelete: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsDelete(poolId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required

Responses


proxyPoolsList

List proxy pools


/proxy-pools

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();

        try {
            proxy_pools_list_200_response result = apiInstance.proxyPoolsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.proxyPoolsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsList: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();

        try {
            proxy_pools_list_200_response result = apiInstance.proxyPoolsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];

// List proxy pools
[apiInstance proxyPoolsListWithCompletionHandler: 
              ^(proxy_pools_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsList(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();

            try {
                // List proxy pools
                proxy_pools_list_200_response result = apiInstance.proxyPoolsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();

try {
    $result = $api_instance->proxyPoolsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();

eval {
    my $result = $api_instance->proxyPoolsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()

try:
    # List proxy pools
    api_response = api_instance.proxy_pools_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsList: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsList(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


proxyPoolsRemoveProxy

Remove proxy from pool


/proxy-pools/{poolId}/proxies/{proxyId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}/proxies/{proxyId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_remove_proxy_200_response result = apiInstance.proxyPoolsRemoveProxy(poolId, proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsRemoveProxy");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 
final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxyPoolsRemoveProxy(poolId, proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsRemoveProxy: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_remove_proxy_200_response result = apiInstance.proxyPoolsRemoveProxy(poolId, proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsRemoveProxy");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Remove proxy from pool
[apiInstance proxyPoolsRemoveProxyWith:poolId
    proxyId:proxyId
              completionHandler: ^(proxy_pools_remove_proxy_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsRemoveProxy(poolId, proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsRemoveProxyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Remove proxy from pool
                proxy_pools_remove_proxy_200_response result = apiInstance.proxyPoolsRemoveProxy(poolId, proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsRemoveProxy: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxyPoolsRemoveProxy($poolId, $proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsRemoveProxy: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxyPoolsRemoveProxy(poolId => $poolId, proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsRemoveProxy: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Remove proxy from pool
    api_response = api_instance.proxy_pools_remove_proxy(poolId, proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsRemoveProxy: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsRemoveProxy(poolId, proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required
proxyId*
UUID (uuid)
Required

Responses


proxyPoolsUpdate

Update proxy pool


/proxy-pools/{poolId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}" \
 -d '{
  "healthCheckEnabled" : true,
  "maxRetries" : 6,
  "isEnabled" : true,
  "healthCheckIntervalSeconds" : 0,
  "name" : "name",
  "description" : "description",
  "timeoutSeconds" : 1,
  "poolStrategy" : "poolStrategy"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsUpdate(poolId, proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 
final ProxyPoolRequest proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

try {
    final result = await api_instance.proxyPoolsUpdate(poolId, proxyPoolRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsUpdate: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsUpdate(poolId, proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
ProxyPoolRequest *proxyPoolRequest = ; // 

// Update proxy pool
[apiInstance proxyPoolsUpdateWith:poolId
    proxyPoolRequest:proxyPoolRequest
              completionHandler: ^(proxy_pools_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var proxyPoolRequest = ; // {ProxyPoolRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsUpdate(poolId, proxyPoolRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

            try {
                // Update proxy pool
                proxy_pools_create_201_response result = apiInstance.proxyPoolsUpdate(poolId, proxyPoolRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$proxyPoolRequest = ; // ProxyPoolRequest | 

try {
    $result = $api_instance->proxyPoolsUpdate($poolId, $proxyPoolRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $proxyPoolRequest = WWW::OPenAPIClient::Object::ProxyPoolRequest->new(); # ProxyPoolRequest | 

eval {
    my $result = $api_instance->proxyPoolsUpdate(poolId => $poolId, proxyPoolRequest => $proxyPoolRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
proxyPoolRequest =  # ProxyPoolRequest | 

try:
    # Update proxy pool
    api_response = api_instance.proxy_pools_update(poolId, proxyPoolRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsUpdate: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let proxyPoolRequest = ; // ProxyPoolRequest

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsUpdate(poolId, proxyPoolRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required
Body parameters
Name Description
proxyPoolRequest *

Responses


Scoring

campaignsRescore

Trigger campaign rescore


/campaigns/{campaignId}/rescore

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/rescore" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Object body = Object; // Object | 

        try {
            SuccessEnvelope result = apiInstance.campaignsRescore(campaignId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#campaignsRescore");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Object body = new Object(); // Object | 

try {
    final result = await api_instance.campaignsRescore(campaignId, body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsRescore: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Object body = Object; // Object | 

        try {
            SuccessEnvelope result = apiInstance.campaignsRescore(campaignId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#campaignsRescore");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Object *body = Object; //  (optional)

// Trigger campaign rescore
[apiInstance campaignsRescoreWith:campaignId
    body:body
              completionHandler: ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsRescore(campaignId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsRescoreExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var body = Object;  // Object |  (optional) 

            try {
                // Trigger campaign rescore
                SuccessEnvelope result = apiInstance.campaignsRescore(campaignId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.campaignsRescore: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$body = Object; // Object | 

try {
    $result = $api_instance->campaignsRescore($campaignId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->campaignsRescore: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->campaignsRescore(campaignId => $campaignId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->campaignsRescore: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
body = Object # Object |  (optional)

try:
    # Trigger campaign rescore
    api_response = api_instance.campaigns_rescore(campaignId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->campaignsRescore: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let body = Object; // Object

    let mut context = ScoringApi::Context::default();
    let result = client.campaignsRescore(campaignId, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
body

Responses


campaignsScoringProfileAssociate

Associate scoring profile with campaign


/campaigns/{campaignId}/scoring-profile

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/scoring-profile" \
 -d '{
  "profileId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        AssociateScoringProfileRequest associateScoringProfileRequest = ; // AssociateScoringProfileRequest | 

        try {
            SuccessEnvelope result = apiInstance.campaignsScoringProfileAssociate(campaignId, associateScoringProfileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#campaignsScoringProfileAssociate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final AssociateScoringProfileRequest associateScoringProfileRequest = new AssociateScoringProfileRequest(); // AssociateScoringProfileRequest | 

try {
    final result = await api_instance.campaignsScoringProfileAssociate(campaignId, associateScoringProfileRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsScoringProfileAssociate: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        AssociateScoringProfileRequest associateScoringProfileRequest = ; // AssociateScoringProfileRequest | 

        try {
            SuccessEnvelope result = apiInstance.campaignsScoringProfileAssociate(campaignId, associateScoringProfileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#campaignsScoringProfileAssociate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
AssociateScoringProfileRequest *associateScoringProfileRequest = ; // 

// Associate scoring profile with campaign
[apiInstance campaignsScoringProfileAssociateWith:campaignId
    associateScoringProfileRequest:associateScoringProfileRequest
              completionHandler: ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var associateScoringProfileRequest = ; // {AssociateScoringProfileRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsScoringProfileAssociate(campaignId, associateScoringProfileRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsScoringProfileAssociateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var associateScoringProfileRequest = new AssociateScoringProfileRequest(); // AssociateScoringProfileRequest | 

            try {
                // Associate scoring profile with campaign
                SuccessEnvelope result = apiInstance.campaignsScoringProfileAssociate(campaignId, associateScoringProfileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.campaignsScoringProfileAssociate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$associateScoringProfileRequest = ; // AssociateScoringProfileRequest | 

try {
    $result = $api_instance->campaignsScoringProfileAssociate($campaignId, $associateScoringProfileRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->campaignsScoringProfileAssociate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $associateScoringProfileRequest = WWW::OPenAPIClient::Object::AssociateScoringProfileRequest->new(); # AssociateScoringProfileRequest | 

eval {
    my $result = $api_instance->campaignsScoringProfileAssociate(campaignId => $campaignId, associateScoringProfileRequest => $associateScoringProfileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->campaignsScoringProfileAssociate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
associateScoringProfileRequest =  # AssociateScoringProfileRequest | 

try:
    # Associate scoring profile with campaign
    api_response = api_instance.campaigns_scoring_profile_associate(campaignId, associateScoringProfileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->campaignsScoringProfileAssociate: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let associateScoringProfileRequest = ; // AssociateScoringProfileRequest

    let mut context = ScoringApi::Context::default();
    let result = client.campaignsScoringProfileAssociate(campaignId, associateScoringProfileRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
associateScoringProfileRequest *

Responses


scoringProfilesCreate

Create scoring profile


/scoring-profiles

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/scoring-profiles" \
 -d '{
  "name" : "name",
  "description" : "description",
  "weights" : {
    "key" : 0.8008282
  },
  "version" : 6
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        CreateScoringProfileRequest createScoringProfileRequest = ; // CreateScoringProfileRequest | 

        try {
            scoring_profiles_create_201_response result = apiInstance.scoringProfilesCreate(createScoringProfileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateScoringProfileRequest createScoringProfileRequest = new CreateScoringProfileRequest(); // CreateScoringProfileRequest | 

try {
    final result = await api_instance.scoringProfilesCreate(createScoringProfileRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scoringProfilesCreate: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        CreateScoringProfileRequest createScoringProfileRequest = ; // CreateScoringProfileRequest | 

        try {
            scoring_profiles_create_201_response result = apiInstance.scoringProfilesCreate(createScoringProfileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
CreateScoringProfileRequest *createScoringProfileRequest = ; // 

// Create scoring profile
[apiInstance scoringProfilesCreateWith:createScoringProfileRequest
              completionHandler: ^(scoring_profiles_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var createScoringProfileRequest = ; // {CreateScoringProfileRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoringProfilesCreate(createScoringProfileRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class scoringProfilesCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var createScoringProfileRequest = new CreateScoringProfileRequest(); // CreateScoringProfileRequest | 

            try {
                // Create scoring profile
                scoring_profiles_create_201_response result = apiInstance.scoringProfilesCreate(createScoringProfileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.scoringProfilesCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$createScoringProfileRequest = ; // CreateScoringProfileRequest | 

try {
    $result = $api_instance->scoringProfilesCreate($createScoringProfileRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->scoringProfilesCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $createScoringProfileRequest = WWW::OPenAPIClient::Object::CreateScoringProfileRequest->new(); # CreateScoringProfileRequest | 

eval {
    my $result = $api_instance->scoringProfilesCreate(createScoringProfileRequest => $createScoringProfileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->scoringProfilesCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
createScoringProfileRequest =  # CreateScoringProfileRequest | 

try:
    # Create scoring profile
    api_response = api_instance.scoring_profiles_create(createScoringProfileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->scoringProfilesCreate: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let createScoringProfileRequest = ; // CreateScoringProfileRequest

    let mut context = ScoringApi::Context::default();
    let result = client.scoringProfilesCreate(createScoringProfileRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createScoringProfileRequest *

Responses


scoringProfilesDelete

Delete scoring profile


/scoring-profiles/{profileId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/scoring-profiles/{profileId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        UUID profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            SuccessEnvelope result = apiInstance.scoringProfilesDelete(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID profileId = new UUID(); // UUID | 

try {
    final result = await api_instance.scoringProfilesDelete(profileId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scoringProfilesDelete: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        UUID profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            SuccessEnvelope result = apiInstance.scoringProfilesDelete(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
UUID *profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete scoring profile
[apiInstance scoringProfilesDeleteWith:profileId
              completionHandler: ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoringProfilesDelete(profileId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class scoringProfilesDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete scoring profile
                SuccessEnvelope result = apiInstance.scoringProfilesDelete(profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.scoringProfilesDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->scoringProfilesDelete($profileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->scoringProfilesDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->scoringProfilesDelete(profileId => $profileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->scoringProfilesDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete scoring profile
    api_response = api_instance.scoring_profiles_delete(profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->scoringProfilesDelete: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ScoringApi::Context::default();
    let result = client.scoringProfilesDelete(profileId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
profileId*
UUID (uuid)
Required

Responses


scoringProfilesGet

Get scoring profile


/scoring-profiles/{profileId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/scoring-profiles/{profileId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        UUID profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            scoring_profiles_create_201_response result = apiInstance.scoringProfilesGet(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID profileId = new UUID(); // UUID | 

try {
    final result = await api_instance.scoringProfilesGet(profileId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scoringProfilesGet: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        UUID profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            scoring_profiles_create_201_response result = apiInstance.scoringProfilesGet(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
UUID *profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get scoring profile
[apiInstance scoringProfilesGetWith:profileId
              completionHandler: ^(scoring_profiles_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoringProfilesGet(profileId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class scoringProfilesGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get scoring profile
                scoring_profiles_create_201_response result = apiInstance.scoringProfilesGet(profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.scoringProfilesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->scoringProfilesGet($profileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->scoringProfilesGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->scoringProfilesGet(profileId => $profileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->scoringProfilesGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get scoring profile
    api_response = api_instance.scoring_profiles_get(profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->scoringProfilesGet: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ScoringApi::Context::default();
    let result = client.scoringProfilesGet(profileId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
profileId*
UUID (uuid)
Required

Responses


scoringProfilesList

List scoring profiles


/scoring-profiles

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/scoring-profiles?limit=56&offset=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset

        try {
            scoring_profiles_list_200_response result = apiInstance.scoringProfilesList(limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset

try {
    final result = await api_instance.scoringProfilesList(limit, offset);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scoringProfilesList: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset

        try {
            scoring_profiles_list_200_response result = apiInstance.scoringProfilesList(limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)

// List scoring profiles
[apiInstance scoringProfilesListWith:limit
    offset:offset
              completionHandler: ^(scoring_profiles_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56 // {Integer} Zero-based offset
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoringProfilesList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class scoringProfilesListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)

            try {
                // List scoring profiles
                scoring_profiles_list_200_response result = apiInstance.scoringProfilesList(limit, offset);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.scoringProfilesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset

try {
    $result = $api_instance->scoringProfilesList($limit, $offset);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->scoringProfilesList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset

eval {
    my $result = $api_instance->scoringProfilesList(limit => $limit, offset => $offset);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->scoringProfilesList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)

try:
    # List scoring profiles
    api_response = api_instance.scoring_profiles_list(limit=limit, offset=offset)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->scoringProfilesList: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer

    let mut context = ScoringApi::Context::default();
    let result = client.scoringProfilesList(limit, offset, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset

Responses


scoringProfilesUpdate

Update scoring profile


/scoring-profiles/{profileId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/scoring-profiles/{profileId}" \
 -d '{
  "name" : "name",
  "description" : "description",
  "weights" : {
    "key" : 0.8008282
  },
  "version" : 6
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ScoringApi;

import java.io.File;
import java.util.*;

public class ScoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ScoringApi apiInstance = new ScoringApi();
        UUID profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateScoringProfileRequest updateScoringProfileRequest = ; // UpdateScoringProfileRequest | 

        try {
            scoring_profiles_create_201_response result = apiInstance.scoringProfilesUpdate(profileId, updateScoringProfileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID profileId = new UUID(); // UUID | 
final UpdateScoringProfileRequest updateScoringProfileRequest = new UpdateScoringProfileRequest(); // UpdateScoringProfileRequest | 

try {
    final result = await api_instance.scoringProfilesUpdate(profileId, updateScoringProfileRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scoringProfilesUpdate: $e\n');
}

import org.openapitools.client.api.ScoringApi;

public class ScoringApiExample {
    public static void main(String[] args) {
        ScoringApi apiInstance = new ScoringApi();
        UUID profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateScoringProfileRequest updateScoringProfileRequest = ; // UpdateScoringProfileRequest | 

        try {
            scoring_profiles_create_201_response result = apiInstance.scoringProfilesUpdate(profileId, updateScoringProfileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScoringApi#scoringProfilesUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ScoringApi *apiInstance = [[ScoringApi alloc] init];
UUID *profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateScoringProfileRequest *updateScoringProfileRequest = ; // 

// Update scoring profile
[apiInstance scoringProfilesUpdateWith:profileId
    updateScoringProfileRequest:updateScoringProfileRequest
              completionHandler: ^(scoring_profiles_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ScoringApi()
var profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateScoringProfileRequest = ; // {UpdateScoringProfileRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoringProfilesUpdate(profileId, updateScoringProfileRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class scoringProfilesUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ScoringApi();
            var profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateScoringProfileRequest = new UpdateScoringProfileRequest(); // UpdateScoringProfileRequest | 

            try {
                // Update scoring profile
                scoring_profiles_create_201_response result = apiInstance.scoringProfilesUpdate(profileId, updateScoringProfileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ScoringApi.scoringProfilesUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ScoringApi();
$profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateScoringProfileRequest = ; // UpdateScoringProfileRequest | 

try {
    $result = $api_instance->scoringProfilesUpdate($profileId, $updateScoringProfileRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ScoringApi->scoringProfilesUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ScoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ScoringApi->new();
my $profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateScoringProfileRequest = WWW::OPenAPIClient::Object::UpdateScoringProfileRequest->new(); # UpdateScoringProfileRequest | 

eval {
    my $result = $api_instance->scoringProfilesUpdate(profileId => $profileId, updateScoringProfileRequest => $updateScoringProfileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ScoringApi->scoringProfilesUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ScoringApi()
profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateScoringProfileRequest =  # UpdateScoringProfileRequest | 

try:
    # Update scoring profile
    api_response = api_instance.scoring_profiles_update(profileId, updateScoringProfileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScoringApi->scoringProfilesUpdate: %s\n" % e)
extern crate ScoringApi;

pub fn main() {
    let profileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateScoringProfileRequest = ; // UpdateScoringProfileRequest

    let mut context = ScoringApi::Context::default();
    let result = client.scoringProfilesUpdate(profileId, updateScoringProfileRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
profileId*
UUID (uuid)
Required
Body parameters
Name Description
updateScoringProfileRequest *

Responses


ServerSettings

configGetAuth

Get authentication configuration


/config/auth

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/auth"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_auth_200_response result = apiInstance.configGetAuth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetAuth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetAuth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetAuth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_auth_200_response result = apiInstance.configGetAuth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetAuth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get authentication configuration
[apiInstance configGetAuthWithCompletionHandler: 
              ^(config_get_auth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetAuth(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetAuthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get authentication configuration
                config_get_auth_200_response result = apiInstance.configGetAuth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetAuth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetAuth();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetAuth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetAuth();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetAuth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get authentication configuration
    api_response = api_instance.config_get_auth()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetAuth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetAuth(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetDns

Get DNS configuration


/config/dns

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/dns"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_dns_200_response result = apiInstance.configGetDns();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetDns");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetDns();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetDns: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_dns_200_response result = apiInstance.configGetDns();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetDns");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get DNS configuration
[apiInstance configGetDnsWithCompletionHandler: 
              ^(config_get_dns_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetDns(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetDnsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get DNS configuration
                config_get_dns_200_response result = apiInstance.configGetDns();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetDns: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetDns();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetDns: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetDns();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetDns: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get DNS configuration
    api_response = api_instance.config_get_dns()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetDns: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetDns(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetHttp

Get HTTP configuration


/config/http

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/http"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetHttp();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetHttp");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetHttp();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetHttp: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetHttp();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetHttp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get HTTP configuration
[apiInstance configGetHttpWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetHttp(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetHttpExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get HTTP configuration
                Object result = apiInstance.configGetHttp();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetHttp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetHttp();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetHttp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetHttp();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetHttp: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get HTTP configuration
    api_response = api_instance.config_get_http()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetHttp: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetHttp(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetLogging

Get logging configuration


/config/logging

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/logging"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_logging_200_response result = apiInstance.configGetLogging();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetLogging");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetLogging();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetLogging: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_logging_200_response result = apiInstance.configGetLogging();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetLogging");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get logging configuration
[apiInstance configGetLoggingWithCompletionHandler: 
              ^(config_get_logging_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetLogging(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetLoggingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get logging configuration
                config_get_logging_200_response result = apiInstance.configGetLogging();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetLogging: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetLogging();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetLogging: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetLogging();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetLogging: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get logging configuration
    api_response = api_instance.config_get_logging()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetLogging: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetLogging(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetProxyManager

Get proxy manager configuration


/config/proxy-manager

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/proxy-manager"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetProxyManager();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetProxyManager");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetProxyManager();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetProxyManager: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetProxyManager();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetProxyManager");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get proxy manager configuration
[apiInstance configGetProxyManagerWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetProxyManager(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetProxyManagerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get proxy manager configuration
                Object result = apiInstance.configGetProxyManager();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetProxyManager: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetProxyManager();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetProxyManager: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetProxyManager();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetProxyManager: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get proxy manager configuration
    api_response = api_instance.config_get_proxy_manager()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetProxyManager: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetProxyManager(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetRateLimiter

Get rate limiter configuration


/config/rate-limit

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/rate-limit"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_rate_limiter_200_response result = apiInstance.configGetRateLimiter();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetRateLimiter");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetRateLimiter();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetRateLimiter: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_rate_limiter_200_response result = apiInstance.configGetRateLimiter();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetRateLimiter");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get rate limiter configuration
[apiInstance configGetRateLimiterWithCompletionHandler: 
              ^(config_get_rate_limiter_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetRateLimiter(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetRateLimiterExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get rate limiter configuration
                config_get_rate_limiter_200_response result = apiInstance.configGetRateLimiter();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetRateLimiter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetRateLimiter();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetRateLimiter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetRateLimiter();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetRateLimiter: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get rate limiter configuration
    api_response = api_instance.config_get_rate_limiter()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetRateLimiter: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetRateLimiter(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetServer

Get server configuration


/config/server

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/server"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetServer();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetServer");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetServer();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetServer: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetServer();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetServer");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get server configuration
[apiInstance configGetServerWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetServer(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetServerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get server configuration
                Object result = apiInstance.configGetServer();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetServer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetServer();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetServer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetServer();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetServer: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get server configuration
    api_response = api_instance.config_get_server()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetServer: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetServer(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetStealth

Get stealth configuration


/config/stealth

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/stealth"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_stealth_200_response result = apiInstance.configGetStealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetStealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetStealth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetStealth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_stealth_200_response result = apiInstance.configGetStealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetStealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get stealth configuration
[apiInstance configGetStealthWithCompletionHandler: 
              ^(config_get_stealth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetStealth(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetStealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get stealth configuration
                config_get_stealth_200_response result = apiInstance.configGetStealth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetStealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetStealth();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetStealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetStealth();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetStealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get stealth configuration
    api_response = api_instance.config_get_stealth()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetStealth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetStealth(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


configGetWorker

Get worker configuration


/config/worker

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/worker"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_worker_200_response result = apiInstance.configGetWorker();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetWorker");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetWorker();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetWorker: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_worker_200_response result = apiInstance.configGetWorker();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetWorker");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get worker configuration
[apiInstance configGetWorkerWithCompletionHandler: 
              ^(config_get_worker_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetWorker(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetWorkerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get worker configuration
                config_get_worker_200_response result = apiInstance.configGetWorker();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetWorker: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetWorker();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetWorker: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetWorker();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetWorker: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get worker configuration
    api_response = api_instance.config_get_worker()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetWorker: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetWorker(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateAuth

Update authentication configuration


/config/auth

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/auth" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_auth_200_response result = apiInstance.configUpdateAuth(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateAuth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateAuth(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateAuth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_auth_200_response result = apiInstance.configUpdateAuth(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateAuth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update authentication configuration
[apiInstance configUpdateAuthWith:requestBody
              completionHandler: ^(config_get_auth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateAuth(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateAuthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update authentication configuration
                config_get_auth_200_response result = apiInstance.configUpdateAuth(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateAuth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateAuth($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateAuth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateAuth(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateAuth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update authentication configuration
    api_response = api_instance.config_update_auth(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateAuth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateAuth(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateDns

Update DNS configuration


/config/dns

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/dns" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_dns_200_response result = apiInstance.configUpdateDns(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateDns");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateDns(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateDns: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_dns_200_response result = apiInstance.configUpdateDns(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateDns");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update DNS configuration
[apiInstance configUpdateDnsWith:requestBody
              completionHandler: ^(config_get_dns_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateDns(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateDnsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update DNS configuration
                config_get_dns_200_response result = apiInstance.configUpdateDns(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateDns: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateDns($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateDns: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateDns(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateDns: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update DNS configuration
    api_response = api_instance.config_update_dns(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateDns: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateDns(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateHttp

Update HTTP configuration


/config/http

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/http" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateHttp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateHttp");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.configUpdateHttp(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateHttp: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateHttp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateHttp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
Object *body = Object; // 

// Update HTTP configuration
[apiInstance configUpdateHttpWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateHttp(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateHttpExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var body = Object;  // Object | 

            try {
                // Update HTTP configuration
                Object result = apiInstance.configUpdateHttp(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateHttp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$body = Object; // Object | 

try {
    $result = $api_instance->configUpdateHttp($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateHttp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->configUpdateHttp(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateHttp: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
body = Object # Object | 

try:
    # Update HTTP configuration
    api_response = api_instance.config_update_http(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateHttp: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let body = Object; // Object

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateHttp(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateLogging

Update logging configuration


/config/logging

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/logging" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_logging_200_response result = apiInstance.configUpdateLogging(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateLogging");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateLogging(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateLogging: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_logging_200_response result = apiInstance.configUpdateLogging(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateLogging");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update logging configuration
[apiInstance configUpdateLoggingWith:requestBody
              completionHandler: ^(config_get_logging_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateLogging(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateLoggingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update logging configuration
                config_get_logging_200_response result = apiInstance.configUpdateLogging(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateLogging: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateLogging($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateLogging: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateLogging(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateLogging: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update logging configuration
    api_response = api_instance.config_update_logging(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateLogging: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateLogging(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateProxyManager

Update proxy manager configuration


/config/proxy-manager

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/proxy-manager" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateProxyManager(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateProxyManager");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.configUpdateProxyManager(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateProxyManager: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateProxyManager(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateProxyManager");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
Object *body = Object; // 

// Update proxy manager configuration
[apiInstance configUpdateProxyManagerWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateProxyManager(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateProxyManagerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var body = Object;  // Object | 

            try {
                // Update proxy manager configuration
                Object result = apiInstance.configUpdateProxyManager(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateProxyManager: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$body = Object; // Object | 

try {
    $result = $api_instance->configUpdateProxyManager($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateProxyManager: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->configUpdateProxyManager(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateProxyManager: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
body = Object # Object | 

try:
    # Update proxy manager configuration
    api_response = api_instance.config_update_proxy_manager(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateProxyManager: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let body = Object; // Object

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateProxyManager(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateRateLimiter

Update rate limiter configuration


/config/rate-limit

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/rate-limit" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_rate_limiter_200_response result = apiInstance.configUpdateRateLimiter(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateRateLimiter");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateRateLimiter(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateRateLimiter: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_rate_limiter_200_response result = apiInstance.configUpdateRateLimiter(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateRateLimiter");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update rate limiter configuration
[apiInstance configUpdateRateLimiterWith:requestBody
              completionHandler: ^(config_get_rate_limiter_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateRateLimiter(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateRateLimiterExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update rate limiter configuration
                config_get_rate_limiter_200_response result = apiInstance.configUpdateRateLimiter(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateRateLimiter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateRateLimiter($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateRateLimiter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateRateLimiter(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateRateLimiter: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update rate limiter configuration
    api_response = api_instance.config_update_rate_limiter(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateRateLimiter: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateRateLimiter(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateServer

Update server configuration


/config/server

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/server" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateServer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateServer");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.configUpdateServer(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateServer: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateServer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateServer");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
Object *body = Object; // 

// Update server configuration
[apiInstance configUpdateServerWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateServer(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateServerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var body = Object;  // Object | 

            try {
                // Update server configuration
                Object result = apiInstance.configUpdateServer(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateServer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$body = Object; // Object | 

try {
    $result = $api_instance->configUpdateServer($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateServer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->configUpdateServer(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateServer: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
body = Object # Object | 

try:
    # Update server configuration
    api_response = api_instance.config_update_server(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateServer: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let body = Object; // Object

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateServer(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateStealth

Update stealth configuration


/config/stealth

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/stealth" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        ConfigGetStealth200ResponseAllOfData configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData | 

        try {
            config_get_stealth_200_response result = apiInstance.configUpdateStealth(configGetStealth200ResponseAllOfData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateStealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ConfigGetStealth200ResponseAllOfData configGetStealth200ResponseAllOfData = new ConfigGetStealth200ResponseAllOfData(); // ConfigGetStealth200ResponseAllOfData | 

try {
    final result = await api_instance.configUpdateStealth(configGetStealth200ResponseAllOfData);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateStealth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        ConfigGetStealth200ResponseAllOfData configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData | 

        try {
            config_get_stealth_200_response result = apiInstance.configUpdateStealth(configGetStealth200ResponseAllOfData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateStealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
ConfigGetStealth200ResponseAllOfData *configGetStealth200ResponseAllOfData = ; // 

// Update stealth configuration
[apiInstance configUpdateStealthWith:configGetStealth200ResponseAllOfData
              completionHandler: ^(config_get_stealth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var configGetStealth200ResponseAllOfData = ; // {ConfigGetStealth200ResponseAllOfData} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateStealth(configGetStealth200ResponseAllOfData, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateStealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var configGetStealth200ResponseAllOfData = new ConfigGetStealth200ResponseAllOfData(); // ConfigGetStealth200ResponseAllOfData | 

            try {
                // Update stealth configuration
                config_get_stealth_200_response result = apiInstance.configUpdateStealth(configGetStealth200ResponseAllOfData);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateStealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData | 

try {
    $result = $api_instance->configUpdateStealth($configGetStealth200ResponseAllOfData);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateStealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $configGetStealth200ResponseAllOfData = WWW::OPenAPIClient::Object::ConfigGetStealth200ResponseAllOfData->new(); # ConfigGetStealth200ResponseAllOfData | 

eval {
    my $result = $api_instance->configUpdateStealth(configGetStealth200ResponseAllOfData => $configGetStealth200ResponseAllOfData);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateStealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
configGetStealth200ResponseAllOfData =  # ConfigGetStealth200ResponseAllOfData | 

try:
    # Update stealth configuration
    api_response = api_instance.config_update_stealth(configGetStealth200ResponseAllOfData)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateStealth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateStealth(configGetStealth200ResponseAllOfData, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
configGetStealth200ResponseAllOfData *

Responses


configUpdateWorker

Update worker configuration


/config/worker

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/worker" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_worker_200_response result = apiInstance.configUpdateWorker(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateWorker");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateWorker(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateWorker: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_worker_200_response result = apiInstance.configUpdateWorker(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateWorker");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update worker configuration
[apiInstance configUpdateWorkerWith:requestBody
              completionHandler: ^(config_get_worker_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateWorker(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateWorkerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update worker configuration
                config_get_worker_200_response result = apiInstance.configUpdateWorker(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateWorker: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateWorker($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateWorker: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateWorker(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateWorker: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update worker configuration
    api_response = api_instance.config_update_worker(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateWorker: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateWorker(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Sse

sseEventsAll

Stream campaign events


/sse/events

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: text/event-stream,application/json" \
 "https://api.domainflow.dev/api/v2/sse/events"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SseApi;

import java.io.File;
import java.util.*;

public class SseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        SseApi apiInstance = new SseApi();

        try {
            'String' result = apiInstance.sseEventsAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.sseEventsAll();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sseEventsAll: $e\n');
}

import org.openapitools.client.api.SseApi;

public class SseApiExample {
    public static void main(String[] args) {
        SseApi apiInstance = new SseApi();

        try {
            'String' result = apiInstance.sseEventsAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsAll");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
SseApi *apiInstance = [[SseApi alloc] init];

// Stream campaign events
[apiInstance sseEventsAllWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.SseApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sseEventsAll(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class sseEventsAllExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new SseApi();

            try {
                // Stream campaign events
                'String' result = apiInstance.sseEventsAll();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SseApi.sseEventsAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SseApi();

try {
    $result = $api_instance->sseEventsAll();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SseApi->sseEventsAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SseApi->new();

eval {
    my $result = $api_instance->sseEventsAll();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SseApi->sseEventsAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.SseApi()

try:
    # Stream campaign events
    api_response = api_instance.sse_events_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SseApi->sseEventsAll: %s\n" % e)
extern crate SseApi;

pub fn main() {

    let mut context = SseApi::Context::default();
    let result = client.sseEventsAll(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


sseEventsCampaign

Stream campaign events (specific campaign)


/sse/campaigns/{campaignId}/events

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: text/event-stream,application/json" \
 "https://api.domainflow.dev/api/v2/sse/campaigns/{campaignId}/events"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SseApi;

import java.io.File;
import java.util.*;

public class SseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        SseApi apiInstance = new SseApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.sseEventsCampaign(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsCampaign");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.sseEventsCampaign(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sseEventsCampaign: $e\n');
}

import org.openapitools.client.api.SseApi;

public class SseApiExample {
    public static void main(String[] args) {
        SseApi apiInstance = new SseApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.sseEventsCampaign(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsCampaign");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
SseApi *apiInstance = [[SseApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Stream campaign events (specific campaign)
[apiInstance sseEventsCampaignWith:campaignId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.SseApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sseEventsCampaign(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class sseEventsCampaignExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new SseApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Stream campaign events (specific campaign)
                'String' result = apiInstance.sseEventsCampaign(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SseApi.sseEventsCampaign: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SseApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->sseEventsCampaign($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SseApi->sseEventsCampaign: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SseApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->sseEventsCampaign(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SseApi->sseEventsCampaign: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.SseApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Stream campaign events (specific campaign)
    api_response = api_instance.sse_events_campaign(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SseApi->sseEventsCampaign: %s\n" % e)
extern crate SseApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = SseApi::Context::default();
    let result = client.sseEventsCampaign(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


sseEventsStats

Get SSE connection statistics


/sse/events/stats

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/sse/events/stats"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SseApi;

import java.io.File;
import java.util.*;

public class SseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        SseApi apiInstance = new SseApi();

        try {
            sse_events_stats_200_response result = apiInstance.sseEventsStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.sseEventsStats();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sseEventsStats: $e\n');
}

import org.openapitools.client.api.SseApi;

public class SseApiExample {
    public static void main(String[] args) {
        SseApi apiInstance = new SseApi();

        try {
            sse_events_stats_200_response result = apiInstance.sseEventsStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
SseApi *apiInstance = [[SseApi alloc] init];

// Get SSE connection statistics
[apiInstance sseEventsStatsWithCompletionHandler: 
              ^(sse_events_stats_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.SseApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sseEventsStats(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class sseEventsStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new SseApi();

            try {
                // Get SSE connection statistics
                sse_events_stats_200_response result = apiInstance.sseEventsStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SseApi.sseEventsStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SseApi();

try {
    $result = $api_instance->sseEventsStats();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SseApi->sseEventsStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SseApi->new();

eval {
    my $result = $api_instance->sseEventsStats();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SseApi->sseEventsStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.SseApi()

try:
    # Get SSE connection statistics
    api_response = api_instance.sse_events_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SseApi->sseEventsStats: %s\n" % e)
extern crate SseApi;

pub fn main() {

    let mut context = SseApi::Context::default();
    let result = client.sseEventsStats(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying